complex

Defined in header <Kokkos_Complex.hpp> which is included from <Kokkos_Core.hpp>

Description

complex is a class template for representing and manipulating complex numbers.

• This is intended as a replacement for std::complex<T>.

• Note: If z has type Kokkos::complex<T>, casting such as reinterpret_cast<T(&)[2]>(z) leads to undefined behavior (this differs from std::complex).

Interface

template<class T>
class complex

Template Parameters:

T – The type of the real and imaginary components.

• T must be a floating point type (float, double, long double) or an extended floating point type.

• T cannot be const and/or volatile qualified.

• Some types might not work with a specific backend (such as long double on CUDA or SYCL).

Public Types:

using value_type = T

Constructors & Assignment Operators:

complex()

Default constructor zero initializes the real and imaginary components.

template<class U>
complex(complex<U> z) noexcept

Conversion constructor initializes the real component to static_cast<T>(z.real()) and the imaginary component to static_cast<T>(z.imag()).

Constraints: U is convertible to T.

complex(std::complex<T> z) noexcept

complex &operator=(std::complex<T> z) noexcept

Implicit conversion from std::complex initializes the real component to z.real() and the imaginary component to z.imag().

constexpr complex(T r) noexcept

constexpr complex &operator=(T r) noexcept

Initializes the real component to r and zero initializes the imaginary component.

constexpr complex(T r, T i) noexcept

Initializes the real component to r and the imaginary component to i.

template<class U>
complex(volatile const complex<U>&) noexcept

Deprecated since version 4.0.0.

void operator=(const complex&) volatile noexcept

Deprecated since version 4.0.0.

volatile complex &operator=(volatile const complex&) volatile noexcept

Deprecated since version 4.0.0.

complex &operator=(volatile const complex&) noexcept

Deprecated since version 4.0.0.

void operator=(volatile const T&) noexcept

Deprecated since version 4.0.0.

void operator=(const T&) volatile noexcept

Deprecated since version 4.0.0.

Note

Some of the deprecated assignment operators have templated implementations so as not to be copy assignment operators.

Public Member Functions:

operator std::complex<T>() const noexcept

Conversion operator to std::complex.

constexpr T &real() noexcept

constexpr T real() const noexcept

Returns:

The value of the real component.

constexpr void real(T r) noexcept

Assigns r to the real component.

constexpr T &imag() noexcept

constexpr T imag() const noexcept

Returns:

The value of the imaginary component.

constexpr void imag(T i) noexcept

Assigns i to the imaginary component.

constexpr complex &operator+=(complex v) noexcept

constexpr complex &operator+=(T v) noexcept

Adds the complex value complex(v) to the complex value *this and stores the sum in *this.

constexpr complex &operator-=(complex v) noexcept

constexpr complex &operator-=(T v) noexcept

Subtracts the complex value complex(v) from the complex value *this and stores the difference in *this.

constexpr complex &operator*=(complex v) noexcept

constexpr complex &operator*=(T v) noexcept

Multiplies the complex value complex(v) by the complex value *this and stores the product in *this.

constexpr complex &operator/=(complex v) noexcept

constexpr complex &operator/=(T v) noexcept

Divides the complex value complex(v) into the complex value *this and stores the quotient in *this.

volatile T &real() volatile noexcept

Deprecated since version 4.0.0.

T real() volatile const noexcept

Deprecated since version 4.0.0.

volatile T &imag() volatile noexcept

Deprecated since version 4.0.0.

T imag() volatile const noexcept

Deprecated since version 4.0.0.

void operator+=(volatile const complex &v) volatile noexcept

Deprecated since version 4.0.0.

void operator+=(volatile const T &v) volatile noexcept

Deprecated since version 4.0.0.

void operator-=(volatile const complex &v) volatile noexcept

Deprecated since version 4.0.0.

void operator-=(volatile const T &v) volatile noexcept

Deprecated since version 4.0.0.

void operator*=(volatile const complex &v) volatile noexcept

Deprecated since version 4.0.0.

void operator*=(volatile const T &v) volatile noexcept

Deprecated since version 4.0.0.

void operator/=(volatile const complex &v) volatile noexcept(noexcept(T{} / T{}))

Deprecated since version 4.0.0.

void operator/=(volatile const T &v) volatile noexcept(noexcept(T{} / T{}))

Deprecated since version 4.0.0.

Non-Member Functions:

template<typename T1, typename T2>
bool operator==(complex<T1> x, complex<T2> y) noexcept

template<typename T1, typename T2>
bool operator==(complex<T1> x, T2 y) noexcept

template<typename T1, typename T2>
bool operator==(T1 x, complex<T2> y) noexcept

template<typename T1, typename T2>
bool operator==(complex<T1> x, std::complex<T2> y) noexcept

template<typename T1, typename T2>
bool operator==(std::complex<T1> x, complex<T2> y) noexcept

Returns:

true if and only if the real component of complex(x) equals the real component of complex(y) and the imaginary component of complex(x) equals the imaginary component of complex(y).

template<typename T1, typename T2>
bool operator!=(complex<T1> x, complex<T2> y) noexcept

template<typename T1, typename T2>
bool operator!=(complex<T1> x, T2 y) noexcept

template<typename T1, typename T2>
bool operator!=(T1 x, complex<T2> y) noexcept

template<typename T1, typename T2>
bool operator!=(complex<T1> x, std::complex<T2> y) noexcept

template<typename T1, typename T2>
bool operator!=(std::complex<T1> x, complex<T2> y) noexcept

Returns:

!(x == y)

template<typename T>
complex<T> operator+(complex<T> x) noexcept

Returns:

x

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator+(complex<T1> x, complex<T2> y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator+(complex<T1> x, T2 y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator+(T1 x, complex<T2> y) noexcept

Returns:

The complex value complex(x) added to the complex value complex(y).

template<typename T>
complex<T> operator-(complex<T> x) noexcept

Returns:

complex(-x.real(), -x.imag())

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator-(complex<T1> x, complex<T2> y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator-(complex<T1> x, T2 y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator-(T1 x, complex<T2> y) noexcept

Returns:

The complex value complex(y) subtracted from the complex value complex(x).

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator*(complex<T1> x, complex<T2> y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator*(complex<T1> x, T2 y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator*(T1 x, complex<T2> y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator*(std::complex<T1> x, complex<T2> y) noexcept

Returns:

The complex value complex(x) multiplied by the complex value complex(y).

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator/(complex<T1> x, complex<T2> y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator/(complex<T1> x, T2 y) noexcept

template<typename T1, typename T2>
complex<std::common_type_t<T1, T2>> operator/(T1 x, complex<T2> y) noexcept

Returns:

The complex value complex(y) divided into the complex value complex(x).

template<typename T>
std::istream &operator>>(std::ostream &i, complex<T> &x)

Extracts a complex number x of the form: u, (u) or (u,v) where u is the real part and v is the imaginary part and returns i.

template<typename T>
std::ostream &operator<<(std::ostream &o, complex<T> x)

Returns:

o << std::complex(x)

template<typename T>
T real(complex<T> x) noexcept

Returns:

x.real().

template<typename T>
T imag(complex<T> x) noexcept

Returns:

x.imag().

template<typenmame T>
complex<T> polar(T rho, T theta = T())

Returns:

The complex value corresponding to a complex number whose magnitude is rho and whose phase angle is theta.

template<typename T>
T abs(complex<T> x)

Returns:

The magnitude of x.

template<typename T1, typename T2>
complex<U> pow(complex<T1> x, complex<T2> y)

template<typename T1, typename T2>
complex<U> pow(complex<T1> x, T2 y)

template<typename T1, typename T2>
complex<U> pow(T1 x, complex<T2> y)

Returns:

The complex power of base x raised to the y-th power, defined as exp(y * log(x)). U is float if T1 and T2 are float; otherwise U is long double if T1 or T2 is long double; otherwise U is double.

template<typename T>
complex<T> sqrt(complex<T> x)

Returns:

The complex square root of x, in the range of the right half-plane.

template<typename T>
complex<T> conj(complex<T> x) noexcept

Returns:

The complex conjugate of x.

template<typename T>
complex<T> exp(complex<T> x)

template<typename T>
complex<T> exp(std::complex<T> x)

Returns:

The complex base-e exponential of complex(x).

template<typename T>
complex<T> log(complex<T> x)

Returns:

The complex natural (base-e) logarithm of x.

template<typename T>
complex<T> log10(complex<T> x)

Returns:

The complex common (base-10) logarithm of x, defined as log(x) / log(10).

template<typename T>
complex<T> sin(complex<T> x)

Returns:

The complex sine of x.

template<typename T>
complex<T> cos(complex<T> x)

Returns:

The complex cosine of x.

template<typename T>
complex<T> tan(complex<T> x)

Returns:

The complex tangent of x.

template<typename T>
complex<T> sinh(complex<T> x)

Returns:

The complex hyperbolic sine of x.

template<typename T>
complex<T> cosh(complex<T> x)

Returns:

The complex hyperbolic cosine of x.

template<typename T>
complex<T> tanh(complex<T> x)

Returns:

The complex hyperbolic tangent of x.

template<typename T>
complex<T> asinh(complex<T> x)

Returns:

The complex arc hyperbolic sine of x.

template<typename T>
complex<T> acosh(complex<T> x)

Returns:

The complex arc hyperbolic cosine of x.

template<typename T>
complex<T> atanh(complex<T> x)

Returns:

The complex arc hyperbolic tangent of x.

template<typename T>
complex<T> asin(complex<T> x)

Returns:

The complex arc sine of x.

template<typename T>
complex<T> acos(complex<T> x)

Returns:

The complex arc cosine of x.

template<typename T>
complex<T> atan(complex<T> x)

Returns:

The complex arc tangent of x.

template<size_t I, typename T>
constexpr T &get(complex<T> &z) noexcept

template<size_t I, typename T>
constexpr T &&get(complex<T> &&z) noexcept

template<size_t I, typename T>
constexpr const T &get(const complex<T> &z) noexcept

template<size_t I, typename T>
constexpr const T &&get(complex<T> &&z) noexcept

Tuple protocol / structured binding support.

Returns:

A reference to the real part of z if I == 0 is true; a reference to the imaginary part of z if I == 1 is true.