std::complex (3) - Linux Manuals

std::complex: std::complex

NAME

std::complex - std::complex

Synopsis

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

The specializations std::complex<float>, std::complex<double>, and std::complex<long double> are LiteralTypes for representing and manipulating complex_numbers.
The effect of instantiating the template complex for any other type is unspecified.

Member types

Member type Definition
value_type T

Member functions

              constructs a complex number
constructor (public member function)
              assigns the contents
operator= (public member function)
              accesses the real part of the complex number
real (public member function)
              accesses the imaginary part of the complex number
imag (public member function)

operator+= compound assignment of two complex numbers or a complex and a scalar
operator-= (public member function)
operator*=
operator/=

Non-member functions

                    applies unary operators to complex numbers
operator+ (function template)
operator-

operator+ performs complex number arithmetics on two complex values or a complex and a scalar
operator- (function template)
operator*
operator/
                    compares two complex numbers or a complex and a scalar
operator== (function template)
operator!=
                    serializes and deserializes a complex number
operator<< (function template)
operator>>
                    returns the real component
real (function template)
                    returns the imaginary component
imag (function template)
                    returns the magnitude of a complex number
abs(std::complex) (function template)
                    returns the phase angle
arg (function template)
                    returns the squared magnitude
norm (function template)
                    returns the complex conjugate
conj (function template)

proj returns the projection onto the Riemann sphere
                    (function template)
(C++11)
                    constructs a complex number from magnitude and phase angle
polar (function template)

Exponential functions

                    complex base e exponential
exp(std::complex) (function template)
                    complex natural logarithm with the branch cuts along the negative real axis
log(std::complex) (function template)
                    complex common logarithm with the branch cuts along the negative real axis
log10(std::complex) (function template)

Power functions

                    complex power, one or both arguments may be a complex number
pow(std::complex) (function template)
                    complex square root in the range of the right half-plane
sqrt(std::complex) (function template)

Trigonometric functions

                    computes sine of a complex number (sin(z))
sin(std::complex) (function template)
                    computes cosine of a complex number (cos(z))
cos(std::complex) (function template)
                    computes tangent of a complex number (tan(z))
tan(std::complex) (function template)

asin(std::complex) computes arc sine of a complex number (arcsin(z))
                    (function template)
(C++11)

acos(std::complex) computes arc cosine of a complex number (arccos(z))
                    (function template)
(C++11)

atan(std::complex) computes arc tangent of a complex number (arctan(z))
                    (function template)
(C++11)

Hyperbolic functions

                    computes hyperbolic sine of a complex number (sh(z))
sinh(std::complex) (function template)
                    computes hyperbolic cosine of a complex number (ch(z))
cosh(std::complex) (function template)
                    computes hyperbolic tangent of a complex number
tanh(std::complex) (function template)

asinh(std::complex) computes area hyperbolic sine of a complex number
                    (function template)
(C++11)

acosh(std::complex) computes area hyperbolic cosine of a complex number
                    (function template)
(C++11)

atanh(std::complex) computes area hyperbolic tangent of a complex number
                    (function template)
(C++11)

Array-oriented access

For any object z of type complex<T>, reinterpret_cast<T(&)[2]>(z)[0] is the real part of z and reinterpret_cast<T(&)[2]>(z)[1] is the imaginary part of z.
For any pointer to an element of an array of complex<T> named p and any valid array index i, reinterpret_cast<T*>(p)[2*i] is the real part of the complex number p[i], and reinterpret_cast<T*>(p)[2*i + 1] is the imaginary part of the complex number p[i] (since C++11)
The intent of this requirement is to preserve binary compatibility between the C++ library complex number types and the C_language_complex_number_types (and arrays thereof), which have an identical object representation requirement.

Implementation notes

In order to satisfy the requirements of array-oriented access, an implementation is constrained to store the real and imaginary components of a std::complex specialization in separate and adjacent memory locations. Possible declarations for its non-static data members include:

* an array of type value_type[2], with the first element holding the real component and the second element holding the imaginary component (e.g. Microsoft Visual Studio)
* a single member of type value_type _Complex (encapsulating the corresponding C_language_complex_number_type) (e.g. GNU libstdc++); (since C++11)
* two members of type value_type, with the same member access, holding the real and the imaginary components respectively (e.g. LLVM libc++).

An implementation cannot declare additional non-static data members that would occupy storage disjoint from the real and imaginary components, and must ensure that the class template specialization does not contain any padding. The implementation must also ensure that optimizations to array access account for the possibility that a pointer to value_type may be aliasing a std::complex specialization or array thereof.

Literals

Defined in inline namespace std::literals::complex_literals

operator""if
operator""i A std::complex literal representing pure imaginary number
operator""il (function)

(C++14)

Example

// Run this code

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

  int main()
  {
      using namespace std::complex_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)