%!TEX root = std.tex

\rSec0[numerics]{Numerics library}

\rSec1[numerics.general]{General}

\pnum

This Clause describes components that \Cpp{} programs may use to perform

seminumerical operations.

\pnum

The following subclauses describe components for

complex number types, random number generation,

numeric (%

\textit{n}-at-a-time)

arrays, generalized numeric algorithms, and

mathematical constants and functions for floating-point types,

as summarized in \tref{numerics.summary}.

\begin{libsumtab}{Numerics library summary}{numerics.summary}

\ref{numeric.requirements} & Requirements & \\ \rowsep

\ref{cfenv} & Floating-point environment & \tcode{<cfenv>} \\ \rowsep

\ref{complex.numbers} & Complex numbers & \tcode{<complex>} \\ \rowsep

\ref{rand} & Random number generation & \tcode{<random>} \\ \rowsep

\ref{numarray} & Numeric arrays & \tcode{<valarray>} \\ \rowsep

\ref{c.math} & Mathematical functions for floating-point types &

\tcode{<cmath>}, \tcode{<cstdlib>} \\ \rowsep

\ref{numbers} & Numbers & \tcode{<numbers>} \\ \rowsep

\ref{linalg} & Linear algebra & \tcode{<linalg>} \\

\end{libsumtab}

\rSec1[numeric.requirements]{Numeric type requirements}

\indextext{requirements!numeric type}

\pnum

The

\tcode{complex}

and

\tcode{valarray}

components are parameterized by the type of information they contain and manipulate.

A \Cpp{} program shall instantiate these components only with a numeric type.

A \defnadj{numeric}{type} is a cv-unqualified object type \tcode{T}

that meets the

\oldconcept{DefaultConstructible},

\oldconcept{CopyConstructible},

\oldconcept{CopyAssignable}, and

\oldconcept{Destructible}

requirements\iref{utility.arg.requirements}.

\begin{footnote}

In other words, value types.

These include arithmetic types,

pointers, the library class

\tcode{complex},

and instantiations of

\tcode{valarray}

for value types.

\end{footnote}

\pnum

If any operation on \tcode{T}

throws an exception the effects are undefined.

\pnum

In addition, many member and related functions of

\tcode{valarray<T>}

can be successfully instantiated

and will exhibit well-defined behavior if and only if

\tcode{T} meets additional requirements specified for each such member

or related function.

\pnum

\begin{example}

It is valid to instantiate

\tcode{valarray<complex>},

but

\tcode{operator>()}

will not be successfully instantiated for

\tcode{valarray<complex>}

operands, since

\tcode{complex}

does not have any ordering operators.

\end{example}

\rSec1[cfenv]{The floating-point environment}

\rSec2[cfenv.syn]{Header \tcode{<cfenv>} synopsis}

\indexheader{cfenv}%

\indexlibraryglobal{fenv_t}%

\indexlibraryglobal{fexcept_t}%

\indexlibraryglobal{feclearexcept}%

\indexlibraryglobal{fegetexceptflag}%

\indexlibraryglobal{feraiseexcept}%

\indexlibraryglobal{fesetexceptflag}%

\indexlibraryglobal{fetestexcept}%

\indexlibraryglobal{fegetround}%

\indexlibraryglobal{fesetround}%

\indexlibraryglobal{fegetenv}%

\indexlibraryglobal{feholdexcept}%

\indexlibraryglobal{fesetenv}%

\indexlibraryglobal{feupdateenv}%

\indexlibraryglobal{FE_ALL_EXCEPT}%

\indexlibraryglobal{FE_DIVBYZERO}%

\indexlibraryglobal{FE_INEXACT}%

\indexlibraryglobal{FE_INVALID}%

\indexlibraryglobal{FE_OVERFLOW}%

\indexlibraryglobal{FE_UNDERFLOW}%

\indexlibraryglobal{FE_DOWNWARD}%

\indexlibraryglobal{FE_TONEAREST}%

\indexlibraryglobal{FE_TOWARDZERO}%

\indexlibraryglobal{FE_UPWARD}%

\indexlibraryglobal{FE_DFL_ENV}%

\begin{codeblock}

#define FE_ALL_EXCEPT @\seebelow@

#define FE_DIVBYZERO @\seebelow@ // optional

#define FE_INEXACT @\seebelow@ // optional

#define FE_INVALID @\seebelow@ // optional

#define FE_OVERFLOW @\seebelow@ // optional

#define FE_UNDERFLOW @\seebelow@ // optional

#define FE_DOWNWARD @\seebelow@ // optional

#define FE_TONEAREST @\seebelow@ // optional

#define FE_TOWARDZERO @\seebelow@ // optional

#define FE_UPWARD @\seebelow@ // optional

#define FE_DFL_ENV @\seebelow@

namespace std {

// types

using fenv_t = @\textit{object type}@;

using fexcept_t = @\textit{object type}@;

// functions

int feclearexcept(int except);

int fegetexceptflag(fexcept_t* pflag, int except);

int feraiseexcept(int except);

int fesetexceptflag(const fexcept_t* pflag, int except);

int fetestexcept(int except);

int fegetround();

int fesetround(int mode);

int fegetenv(fenv_t* penv);

int feholdexcept(fenv_t* penv);

int fesetenv(const fenv_t* penv);

int feupdateenv(const fenv_t* penv);

}

\end{codeblock}

\pnum

The contents and meaning of the header \libheader{cfenv}

are the same as the C standard library header \libheader{fenv.h}.

\begin{note}

This document does not require an implementation to support the

\tcode{FENV_ACCESS} pragma;

it is \impldef{whether pragma \tcode{FENV_ACCESS} is supported}\iref{cpp.pragma}

whether the pragma is supported. As a consequence,

it is \impldef{whether \tcode{<cfenv>} functions can be used to manage floating-point status}

whether these functions can be used to test floating-point status flags,

set floating-point control modes, or run under non-default mode settings.

If the pragma is used to enable control over the floating-point environment,

this document does not specify the effect on

floating-point evaluation in constant expressions.

\end{note}

\xrefc{7.6}

\rSec2[cfenv.thread]{Threads}

\pnum

The floating-point environment has thread storage

duration\iref{basic.stc.thread}. The initial state for a thread's floating-point

environment is the state of the floating-point environment of the thread that constructs

the corresponding \tcode{thread} object\iref{thread.thread.class}

or \tcode{jthread} object\iref{thread.jthread.class}

at the time it

constructed the object.

\begin{note}

That is, the child thread gets the floating-point

state of the parent thread at the time of the child's creation.

\end{note}

\pnum

A separate floating-point environment is maintained for each thread. Each function

accesses the environment corresponding to its calling thread.

\rSec1[complex.numbers]{Complex numbers}

\rSec2[complex.numbers.general]{General}

\pnum

The header \libheader{complex} defines a class template,

and numerous functions for representing and manipulating complex numbers.

\pnum

The effect of instantiating the template \tcode{complex} for any type

that is not a cv-unqualified floating-point type\iref{basic.fundamental}

is unspecified.

Specializations of \tcode{complex} for cv-unqualified floating-point types

are trivially copyable literal types\iref{term.literal.type}.

\pnum

If the result of a function is not mathematically defined or not in

the range of representable values for its type, the behavior is

undefined.

\pnum

If \tcode{z} is an lvalue of type \cv{} \tcode{complex<T>} then:

\begin{itemize}

\item the expression \tcode{reinterpret_cast<\cv{} T(\&)[2]>(z)} is well-formed,

\item \tcode{reinterpret_cast<\cv{} T(\&)[2]>(z)[0]} designates the real part of \tcode{z}, and

\item \tcode{reinterpret_cast<\cv{} T(\&)[2]>(z)[1]} designates the imaginary part of \tcode{z}.

\end{itemize}

Moreover, if \tcode{a} is an expression of type \cv{}~\tcode{complex<T>*} and the expression \tcode{a[i]} is well-defined for an integer expression \tcode{i}, then:

\begin{itemize}

\item \tcode{reinterpret_cast<\cv{} T*>(a)[2*i]} designates the real part of \tcode{a[i]}, and

\item \tcode{reinterpret_cast<\cv{} T*>(a)[2*i + 1]} designates the imaginary part of \tcode{a[i]}.

\end{itemize}

\rSec2[complex.syn]{Header \tcode{<complex>} synopsis}

\indexheader{complex}%

\begin{codeblock}

namespace std {

// \ref{complex}, class template \tcode{complex}

template<class T> class complex;

// \ref{complex.ops}, operators

template<class T> constexpr complex<T> operator+(const complex<T>&, const complex<T>&);

template<class T> constexpr complex<T> operator+(const complex<T>&, const T&);

template<class T> constexpr complex<T> operator+(const T&, const complex<T>&);

template<class T> constexpr complex<T> operator-(const complex<T>&, const complex<T>&);

template<class T> constexpr complex<T> operator-(const complex<T>&, const T&);

template<class T> constexpr complex<T> operator-(const T&, const complex<T>&);

template<class T> constexpr complex<T> operator*(const complex<T>&, const complex<T>&);

template<class T> constexpr complex<T> operator*(const complex<T>&, const T&);

template<class T> constexpr complex<T> operator*(const T&, const complex<T>&);

template<class T> constexpr complex<T> operator/(const complex<T>&, const complex<T>&);

template<class T> constexpr complex<T> operator/(const complex<T>&, const T&);

template<class T> constexpr complex<T> operator/(const T&, const complex<T>&);

template<class T> constexpr complex<T> operator+(const complex<T>&);

template<class T> constexpr complex<T> operator-(const complex<T>&);

template<class T> constexpr bool operator==(const complex<T>&, const complex<T>&);

template<class T> constexpr bool operator==(const complex<T>&, const T&);

template<class T, class charT, class traits>

basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, complex<T>&);

template<class T, class charT, class traits>

basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const complex<T>&);

// \ref{complex.value.ops}, values

template<class T> constexpr T real(const complex<T>&);

template<class T> constexpr T imag(const complex<T>&);

template<class T> constexpr T abs(const complex<T>&);

template<class T> constexpr T arg(const complex<T>&);

template<class T> constexpr T norm(const complex<T>&);

template<class T> constexpr complex<T> conj(const complex<T>&);

template<class T> constexpr complex<T> proj(const complex<T>&);

template<class T> constexpr complex<T> polar(const T&, const T& = T());

// \ref{complex.transcendentals}, transcendentals

template<class T> constexpr complex<T> acos(const complex<T>&);

template<class T> constexpr complex<T> asin(const complex<T>&);

template<class T> constexpr complex<T> atan(const complex<T>&);

template<class T> constexpr complex<T> acosh(const complex<T>&);

template<class T> constexpr complex<T> asinh(const complex<T>&);

template<class T> constexpr complex<T> atanh(const complex<T>&);

template<class T> constexpr complex<T> cos (const complex<T>&);

template<class T> constexpr complex<T> cosh (const complex<T>&);

template<class T> constexpr complex<T> exp (const complex<T>&);

template<class T> constexpr complex<T> log (const complex<T>&);

template<class T> constexpr complex<T> log10(const complex<T>&);

template<class T> constexpr complex<T> pow (const complex<T>&, const T&);

template<class T> constexpr complex<T> pow (const complex<T>&, const complex<T>&);

template<class T> constexpr complex<T> pow (const T&, const complex<T>&);

template<class T> constexpr complex<T> sin (const complex<T>&);

template<class T> constexpr complex<T> sinh (const complex<T>&);

template<class T> constexpr complex<T> sqrt (const complex<T>&);

template<class T> constexpr complex<T> tan (const complex<T>&);

template<class T> constexpr complex<T> tanh (const complex<T>&);

// \ref{complex.tuple}, tuple interface

template<class T> struct tuple_size;

template<size_t I, class T> struct tuple_element;

template<class T> struct tuple_size<complex<T>>;

template<size_t I, class T> struct tuple_element<I, complex<T>>;

template<size_t I, class T>

constexpr T& get(complex<T>&) noexcept;

template<size_t I, class T>

constexpr T&& get(complex<T>&&) noexcept;

template<size_t I, class T>

constexpr const T& get(const complex<T>&) noexcept;

template<size_t I, class T>

constexpr const T&& get(const complex<T>&&) noexcept;

// \ref{complex.literals}, complex literals

inline namespace literals {

inline namespace complex_literals {

constexpr complex<long double> operator""il(long double);

constexpr complex<long double> operator""il(unsigned long long);

constexpr complex<double> operator""i(long double);

constexpr complex<double> operator""i(unsigned long long);

constexpr complex<float> operator""if(long double);

constexpr complex<float> operator""if(unsigned long long);

}

}

}

\end{codeblock}

\rSec2[complex]{Class template \tcode{complex}}

\indexlibraryglobal{complex}%

\indexlibrarymember{value_type}{complex}%

\begin{codeblock}

namespace std {

template<class T> class complex {

public:

using value_type = T;

constexpr complex(const T& re = T(), const T& im = T());

constexpr complex(const complex&) = default;

template<class X> constexpr explicit(@\seebelow@) complex(const complex<X>&);

constexpr T real() const;

constexpr void real(T);

constexpr T imag() const;

constexpr void imag(T);

constexpr complex& operator= (const T&);

constexpr complex& operator+=(const T&);

constexpr complex& operator-=(const T&);

constexpr complex& operator*=(const T&);

constexpr complex& operator/=(const T&);

constexpr complex& operator=(const complex&);

template<class X> constexpr complex& operator= (const complex<X>&);

template<class X> constexpr complex& operator+=(const complex<X>&);

template<class X> constexpr complex& operator-=(const complex<X>&);

template<class X> constexpr complex& operator*=(const complex<X>&);

template<class X> constexpr complex& operator/=(const complex<X>&);

};

}

\end{codeblock}

\pnum

The class

\tcode{complex}

describes an object that can

store the Cartesian components,

\tcode{real()}

and

\tcode{imag()},

of a complex

number.

\rSec2[complex.members]{Member functions}

\indexlibraryctor{complex}%

\begin{itemdecl}

constexpr complex(const T& re = T(), const T& im = T());

\end{itemdecl}

\begin{itemdescr}

\pnum

\ensures

\tcode{real() == re \&\& imag() == im} is \tcode{true}.

\end{itemdescr}

\indexlibraryctor{complex}%

\begin{itemdecl}

template<class X> constexpr explicit(@\seebelow@) complex(const complex<X>& other);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Initializes the real part with \tcode{other.real()} and

the imaginary part with \tcode{other.imag()}.

\pnum

\remarks

The expression inside \tcode{explicit} evaluates to \tcode{false}

if and only if the floating-point conversion rank of \tcode{T}

is greater than or equal to the floating-point conversion rank of \tcode{X}.

\end{itemdescr}

\indexlibrarymember{real}{complex}%

\begin{itemdecl}

constexpr T real() const;

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The value of the real component.

\end{itemdescr}

\indexlibrarymember{real}{complex}%

\begin{itemdecl}

constexpr void real(T val);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Assigns \tcode{val} to the real component.

\end{itemdescr}

\indexlibrarymember{imag}{complex}%

\begin{itemdecl}

constexpr T imag() const;

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The value of the imaginary component.

\end{itemdescr}

\indexlibrarymember{imag}{complex}%

\begin{itemdecl}

constexpr void imag(T val);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Assigns \tcode{val} to the imaginary component.

\end{itemdescr}

\rSec2[complex.member.ops]{Member operators}

\indexlibrarymember{operator+=}{complex}%

\begin{itemdecl}

constexpr complex& operator+=(const T& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Adds the scalar value \tcode{rhs} to the real part of the complex value

\tcode{*this}

and stores the result in the real part of

\tcode{*this},

leaving the imaginary part unchanged.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator-=}{complex}%

\begin{itemdecl}

constexpr complex& operator-=(const T& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Subtracts the scalar value \tcode{rhs} from the real part of the complex value

\tcode{*this}

and stores the result in the real part of

\tcode{*this},

leaving the imaginary part unchanged.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator*=}{complex}%

\begin{itemdecl}

constexpr complex& operator*=(const T& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Multiplies the scalar value \tcode{rhs} by the complex value

\tcode{*this}

and stores the result in

\tcode{*this}.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator/=}{complex}%

\begin{itemdecl}

constexpr complex& operator/=(const T& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Divides the scalar value \tcode{rhs} into the complex value

\tcode{*this}

and stores the result in

\tcode{*this}.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator=}{complex}%

\begin{itemdecl}

template<class X> constexpr complex& operator=(const complex<X>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Assigns the value \tcode{rhs.real()} to the real part and

the value \tcode{rhs.imag()} to the imaginary part

of the complex value \tcode{*this}.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator+=}{complex}%

\begin{itemdecl}

template<class X> constexpr complex& operator+=(const complex<X>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Adds the complex value \tcode{rhs} to the complex value

\tcode{*this}

and stores the sum in

\tcode{*this}.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator-=}{complex}%

\begin{itemdecl}

template<class X> constexpr complex& operator-=(const complex<X>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Subtracts the complex value \tcode{rhs} from the complex value

\tcode{*this}

and stores the difference in

\tcode{*this}.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator*=}{complex}%

\begin{itemdecl}

template<class X> constexpr complex& operator*=(const complex<X>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Multiplies the complex value \tcode{rhs} by the complex value

\tcode{*this}

and stores the product in

\tcode{*this}.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator/=}{complex}%

\begin{itemdecl}

template<class X> constexpr complex& operator/=(const complex<X>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Divides the complex value \tcode{rhs} into the complex value

\tcode{*this}

and stores the quotient in

\tcode{*this}.

\pnum

\returns

\tcode{*this}.

\end{itemdescr}

\rSec2[complex.ops]{Non-member operations}

\indexlibrarymember{operator+}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> operator+(const complex<T>& lhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{complex<T>(lhs)}.

\end{itemdescr}

\begin{itemdecl}

template<class T> constexpr complex<T> operator+(const complex<T>& lhs, const complex<T>& rhs);

template<class T> constexpr complex<T> operator+(const complex<T>& lhs, const T& rhs);

template<class T> constexpr complex<T> operator+(const T& lhs, const complex<T>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{complex<T>(lhs) += rhs}.

\end{itemdescr}

\indexlibrarymember{operator-}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> operator-(const complex<T>& lhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{complex<T>(-lhs.real(),-lhs.imag())}.

\end{itemdescr}

\indexlibrarymember{operator-}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> operator-(const complex<T>& lhs, const complex<T>& rhs);

template<class T> constexpr complex<T> operator-(const complex<T>& lhs, const T& rhs);

template<class T> constexpr complex<T> operator-(const T& lhs, const complex<T>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{complex<T>(lhs) -= rhs}.

\end{itemdescr}

\indexlibrarymember{operator*}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> operator*(const complex<T>& lhs, const complex<T>& rhs);

template<class T> constexpr complex<T> operator*(const complex<T>& lhs, const T& rhs);

template<class T> constexpr complex<T> operator*(const T& lhs, const complex<T>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{complex<T>(lhs) *= rhs}.

\end{itemdescr}

\indexlibrarymember{operator/}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> operator/(const complex<T>& lhs, const complex<T>& rhs);

template<class T> constexpr complex<T> operator/(const complex<T>& lhs, const T& rhs);

template<class T> constexpr complex<T> operator/(const T& lhs, const complex<T>& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{complex<T>(lhs) /= rhs}.

\end{itemdescr}

\indexlibrarymember{operator==}{complex}%

\begin{itemdecl}

template<class T> constexpr bool operator==(const complex<T>& lhs, const complex<T>& rhs);

template<class T> constexpr bool operator==(const complex<T>& lhs, const T& rhs);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{lhs.real() == rhs.real() \&\& lhs.imag() == rhs.imag()}.

\pnum

\remarks

The imaginary part is assumed to be

\tcode{T()},

or 0.0, for the

\tcode{T}

arguments.

\end{itemdescr}

\indexlibrarymember{operator>>}{complex}%

\begin{itemdecl}

template<class T, class charT, class traits>

basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\expects

The input values are convertible to

\tcode{T}.

\pnum

\effects

Extracts a complex number \tcode{x} of the form:

\tcode{u},

\tcode{(u)},

or

\tcode{(u,v)},

where

\tcode{u}

is the real part and

\tcode{v}

is the imaginary part\iref{istream.formatted}.

\pnum

If bad input is encountered, calls

\tcode{is.setstate(ios_base::failbit)}

(which may throw

\tcode{ios_base::\brk{}failure}\iref{iostate.flags}).

\pnum

\returns

\tcode{is}.

\pnum

\remarks

This extraction is performed as a series of simpler

extractions.

Therefore, the skipping of whitespace is specified to be

the same for each of the simpler extractions.

\end{itemdescr}

\indexlibrarymember{operator<<}{complex}%

\begin{itemdecl}

template<class T, class charT, class traits>

basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& o, const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Inserts the complex number \tcode{x}

onto the stream \tcode{o} as if it were implemented as follows:

\begin{codeblock}

basic_ostringstream<charT, traits> s;

s.flags(o.flags());

s.imbue(o.getloc());

s.precision(o.precision());

s << '(' << x.real() << ',' << x.imag() << ')';

return o << s.str();

\end{codeblock}

\pnum

\begin{note}

In a locale in which comma is used as a decimal point character, the

use of comma as a field separator can be ambiguous. Inserting

\tcode{showpoint} into the output stream forces all outputs to

show an explicit decimal point character; as a result, all inserted sequences of

complex numbers can be extracted unambiguously.

\end{note}

\end{itemdescr}

\rSec2[complex.value.ops]{Value operations}

\indexlibrarymember{real}{complex}%

\begin{itemdecl}

template<class T> constexpr T real(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{x.real()}.

\end{itemdescr}

\indexlibrarymember{imag}{complex}%

\begin{itemdecl}

template<class T> constexpr T imag(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

\tcode{x.imag()}.

\end{itemdescr}

\indexlibrarymember{abs}{complex}%

\begin{itemdecl}

template<class T> constexpr T abs(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The magnitude of \tcode{x}.

\end{itemdescr}

\indexlibrarymember{arg}{complex}%

\begin{itemdecl}

template<class T> constexpr T arg(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The phase angle of \tcode{x}, or \tcode{atan2(imag(x), real(x))}.

\end{itemdescr}

\indexlibrarymember{norm}{complex}%

\begin{itemdecl}

template<class T> constexpr T norm(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The squared magnitude of \tcode{x}.

\end{itemdescr}

\indexlibrarymember{conj}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> conj(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex conjugate of \tcode{x}.

\end{itemdescr}

\indexlibrarymember{proj}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> proj(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The projection of \tcode{x} onto the Riemann sphere.

\pnum

\remarks

Behaves the same as the C function \tcode{cproj}.

\xrefc{7.3.9.5}

\end{itemdescr}

\indexlibrarymember{polar}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> polar(const T& rho, const T& theta = T());

\end{itemdecl}

\begin{itemdescr}

\pnum

\expects

\tcode{rho} is non-negative and non-NaN\@. \tcode{theta} is finite.

\pnum

\returns

The

\tcode{complex}

value corresponding

to a complex number whose magnitude is \tcode{rho} and whose phase angle

is \tcode{theta}.

\end{itemdescr}

\rSec2[complex.transcendentals]{Transcendentals}

\indexlibrarymember{acos}{complex}%

\indexlibrarymember{cacos}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> acos(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex arc cosine of \tcode{x}.

\pnum

\remarks

Behaves the same as the C function \tcode{cacos}.

\xrefc{7.3.5.1}

\end{itemdescr}

\indexlibrarymember{asin}{complex}%

\indexlibrarymember{casin}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> asin(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex arc sine of \tcode{x}.

\pnum

\remarks

Behaves the same as the C function \tcode{casin}.

\xrefc{7.3.5.2}

\end{itemdescr}

\indexlibrarymember{atan}{complex}%

\indexlibrarymember{catan}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> atan(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex arc tangent of \tcode{x}.

\pnum

\remarks

Behaves the same as the C function \tcode{catan}.

\xrefc{7.3.5.3}

\end{itemdescr}

\indexlibrarymember{acosh}{complex}%

\indexlibrarymember{cacosh}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> acosh(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex arc hyperbolic cosine of \tcode{x}.

\pnum

\remarks

Behaves the same as the C function \tcode{cacosh}.

\xrefc{7.3.6.1}

\end{itemdescr}

\indexlibrarymember{asinh}{complex}%

\indexlibrarymember{casinh}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> asinh(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex arc hyperbolic sine of \tcode{x}.

\pnum

\remarks

Behaves the same as the C function \tcode{casinh}.

\xrefc{7.3.6.2}

\end{itemdescr}

\indexlibrarymember{atanh}{complex}%

\indexlibrarymember{catanh}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> atanh(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex arc hyperbolic tangent of \tcode{x}.

\pnum

\remarks

Behaves the same as the C function \tcode{catanh}.

\xrefc{7.3.6.3}

\end{itemdescr}

\indexlibrarymember{cos}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> cos(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}

\pnum

\returns

The complex cosine of \tcode{x}.

\end{itemdescr}

\indexlibrarymember{cosh}{complex}%

\begin{itemdecl}

template<class T> constexpr complex<T> cosh(const complex<T>& x);

\end{itemdecl}

\begin{itemdescr}