Standard library header <complex>

From cppreference.com
< cpp‎ | header
 
 
 

This header is part of the numeric library.

Classes

a complex number type
(class template)
a complex number type
(class template specialization)

Functions

Operations
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)
Literals
A std::complex literal representing pure imaginary number
(function)


Synopsis

namespace std {
 
    template<class T> class complex;
 
    template<> class complex<float>;
    template<> class complex<double>;
    template<> class complex<long double>;
 
    // 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> constexpr bool operator==(const T&, 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> constexpr bool operator!=(const T&, const complex<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>&);
 
    // values:
    template<class T> constexpr T real(const complex<T>&);
    template<class T> constexpr T imag(const complex<T>&);
 
    template<class T> T abs(const complex<T>&);
    template<class T> 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> complex<T> proj(const complex<T>&);
    template<class T> complex<T> polar(const T&, const T& = 0);
 
    // transcendentals:
    template<class T> complex<T> acos(const complex<T>&);
    template<class T> complex<T> asin(const complex<T>&);
    template<class T> complex<T> atan(const complex<T>&);
 
    template<class T> complex<T> acosh(const complex<T>&);
    template<class T> complex<T> asinh(const complex<T>&);
    template<class T> complex<T> atanh(const complex<T>&);
 
    template<class T> complex<T> cos  (const complex<T>&);
    template<class T> complex<T> cosh (const complex<T>&);
    template<class T> complex<T> exp  (const complex<T>&);
    template<class T> complex<T> log  (const complex<T>&);
    template<class T> complex<T> log10(const complex<T>&);
 
    template<class T> complex<T> pow(const complex<T>&, const T&);
    template<class T> complex<T> pow(const complex<T>&, const complex<T>&);
    template<class T> complex<T> pow(const T&, const complex<T>&);
 
    template<class T> complex<T> sin    (const complex<T>&);
    template<class T> complex<T> sinh   (const complex<T>&);
    template<class T> complex<T> sqrt   (const complex<T>&);
    template<class T> complex<T> tan    (const complex<T>&);
    template<class T> complex<T> tanh   (const complex<T>&);
 
    // 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);
    }
    }
}

Class std::complex

template<class T>
class complex {
public:
    typedef T value_type;
    constexpr complex(const T& re = T(), const T& im = T());
    constexpr complex(const complex&);
    template<class X> constexpr complex(const complex<X>&);
 
    constexpr T real() const;
    constexpr void real(T);
    constexpr T imag() const;
    constexpr void imag(T);
 
    constexpr complex<T>& operator= (const T&);
    constexpr complex<T>& operator+=(const T&);
    constexpr complex<T>& operator-=(const T&);
    constexpr complex<T>& operator*=(const T&);
    constexpr complex<T>& operator/=(const T&);
 
    constexpr complex& operator=(const complex&);     
    template<class X> constexpr complex<T>& operator= (const complex<X>&);   
    template<class X> constexpr complex<T>& operator+=(const complex<X>&);   
    template<class X> constexpr complex<T>& operator-=(const complex<X>&);   
    template<class X> constexpr complex<T>& operator*=(const complex<X>&);   
    template<class X> constexpr complex<T>& operator/=(const complex<X>&);   
 
};

std::complex specializations

template<> class complex<float> {
public:
    typedef float value_type;
 
    constexpr complex(float re = 0.0f, float im = 0.0f);
    explicit constexpr complex(const complex<double>&);
    explicit constexpr complex(const complex<long double>&);
 
    constexpr float real() const;
    constexpr void real(float);
    constexpr float imag() const;
    constexpr void imag(float);
 
    constexpr complex<float>& operator= (float);
    constexpr complex<float>& operator+=(float);
    constexpr complex<float>& operator-=(float);
    constexpr complex<float>& operator*=(float);
    constexpr complex<float>& operator/=(float);
 
    constexpr complex<float>& operator=(const complex<float>&);
    template<class X> constexpr complex<float>& operator= (const complex<X>&);
    template<class X> constexpr complex<float>& operator+=(const complex<X>&);
    template<class X> constexpr complex<float>& operator-=(const complex<X>&);
    template<class X> constexpr complex<float>& operator*=(const complex<X>&);
    template<class X> constexpr complex<float>& operator/=(const complex<X>&);
};
 
template<> class complex<double> {
public:
    typedef double value_type;
 
    constexpr complex(double re = 0.0, double im = 0.0);
    constexpr complex(const complex<float>&);
    explicit constexpr complex(const complex<long double>&);
 
    constexpr double real() const;
    constexpr void real(double);
    constexpr double imag() const;
    constexpr void imag(double);
 
    constexpr complex<double>& operator= (double);
    constexpr complex<double>& operator+=(double);
    constexpr complex<double>& operator-=(double);
    constexpr complex<double>& operator*=(double);
    constexpr complex<double>& operator/=(double);
 
    constexpr complex<double>& operator=(const complex<double>&);
    template<class X> constexpr complex<double>& operator= (const complex<X>&);
    template<class X> constexpr complex<double>& operator+=(const complex<X>&);
    template<class X> constexpr complex<double>& operator-=(const complex<X>&);
    template<class X> constexpr complex<double>& operator*=(const complex<X>&);
    template<class X> constexpr complex<double>& operator/=(const complex<X>&);
};
 
template<> class complex<long double> {
public:
    typedef long double value_type;
 
    constexpr complex(long double re = 0.0L, long double im = 0.0L);
    constexpr complex(const complex<float>&);
    constexpr complex(const complex<double>&);
 
    constexpr long double real() const;
    constexpr void real(long double);
    constexpr long double imag() const;
    constexpr void imag(long double);
 
    constexpr complex<long double>& operator=(const complex<long double>&);
    constexpr complex<long double>& operator= (long double);
    constexpr complex<long double>& operator+=(long double);
    constexpr complex<long double>& operator-=(long double);
    constexpr complex<long double>& operator*=(long double);
    constexpr complex<long double>& operator/=(long double);
 
    template<class X> constexpr complex<long double>& operator= (const complex<X>&);
    template<class X> constexpr complex<long double>& operator+=(const complex<X>&);
    template<class X> constexpr complex<long double>& operator-=(const complex<X>&);
    template<class X> constexpr complex<long double>& operator*=(const complex<X>&);
    template<class X> constexpr complex<long double>& operator/=(const complex<X>&);
 
};