MENU
Edit
In Place Editing Advanced Editing

complex

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)
(C++11)
 computes arc sine of a complex number (arcsin(z))
(function template)
(C++11)
 computes arc cosine of a complex number (arccos(z))
(function template)
(C++11)
 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)
(C++11)
 computes area hyperbolic sine of a complex number
(function template)
(C++11)
 computes area hyperbolic cosine of a complex number
(function template)
(C++11)
 computes area hyperbolic tangent of a complex number
(function template)

Synopsis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
namespace std {
  
    template<class T> class complex;
  
    template<> class complex<float>;
    template<> class complex<double>;
    template<> class complex<long double>;
  
    // operators:
    template<class T>
    complex<T> operator+(const complex<T>&, const complex<T>&);
    template<class T> complex<T> operator+(const complex<T>&, const T&);
    template<class T> complex<T> operator+(const T&, const complex<T>&);
  
    template<class T> complex<T> operator-(
        const complex<T>&, const complex<T>&);
    template<class T> complex<T> operator-(const complex<T>&, const T&);
    template<class T> complex<T> operator-(const T&, const complex<T>&);
  
    template<class T> complex<T> operator*(
        const complex<T>&, const complex<T>&);
    template<class T> complex<T> operator*(const complex<T>&, const T&);
    template<class T> complex<T> operator*(const T&, const complex<T>&);
  
    template<class T> complex<T> operator/(
        const complex<T>&, const complex<T>&);
    template<class T> complex<T> operator/(const complex<T>&, const T&);
    template<class T> complex<T> operator/(const T&, const complex<T>&);
  
    template<class T> complex<T> operator+(const complex<T>&);
    template<class T> complex<T> operator-(const complex<T>&);
  
    template<class T> bool operator==(
        const complex<T>&, const complex<T>&);
    template<class T> bool operator==(const complex<T>&, const T&);
    template<class T> bool operator==(const T&, const complex<T>&);
  
    template<class T> bool operator!=(const complex<T>&, const complex<T>&);
    template<class T> bool operator!=(const complex<T>&, const T&);
    template<class T> 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> T real(const complex<T>&);
    template<class T> T imag(const complex<T>&);
  
    template<class T> T abs(const complex<T>&);
    template<class T> T arg(const complex<T>&);
    template<class T> T norm(const complex<T>&);
  
    template<class T> 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>&);
  
  
}

Class std::complex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
template<class T>
class complex {
public:
    typedef T value_type;
    complex(const T& re = T(), const T& im = T());
    complex(const complex&);
    template<class X> complex(const complex<X>&);
  
    T real() const;
    void real(T);
    T imag() const;
    void imag(T);
  
    complex<T>& operator= (const T&);
    complex<T>& operator+=(const T&);
    complex<T>& operator-=(const T&);
    complex<T>& operator*=(const T&);
    complex<T>& operator/=(const T&);
  
    complex& operator=(const complex&);    
    template<class X> complex<T>& operator= (const complex<X>&);  
    template<class X> complex<T>& operator+=(const complex<X>&);  
    template<class X> complex<T>& operator-=(const complex<X>&);  
    template<class X> complex<T>& operator*=(const complex<X>&);  
    template<class X> complex<T>& operator/=(const complex<X>&);  
  
};

std::complex specializations

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
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();
    void real(float);
    constexpr float imag();
    void imag(float);
  
    complex<float>& operator= (float);
    complex<float>& operator+=(float);
    complex<float>& operator-=(float);
    complex<float>& operator*=(float);
    complex<float>& operator/=(float);
  
    complex<float>& operator=(const complex<float>&);
    template<class X> complex<float>& operator= (const complex<X>&);
    template<class X> complex<float>& operator+=(const complex<X>&);
    template<class X> complex<float>& operator-=(const complex<X>&);
    template<class X> complex<float>& operator*=(const complex<X>&);
    template<class X> 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();
    void real(double);
    constexpr double imag();
    void imag(double);
  
    complex<double>& operator= (double);
    complex<double>& operator+=(double);
    complex<double>& operator-=(double);
    complex<double>& operator*=(double);
    complex<double>& operator/=(double);
  
    complex<double>& operator=(const complex<double>&);
    template<class X> complex<double>& operator= (const complex<X>&);
    template<class X> complex<double>& operator+=(const complex<X>&);
    template<class X> complex<double>& operator-=(const complex<X>&);
    template<class X> complex<double>& operator*=(const complex<X>&);
    template<class X> 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();
    void real(long double);
    constexpr long double imag();
    void imag(long double);
  
    complex<long double>& operator=(const complex<long double>&);
    complex<long double>& operator= (long double);
    complex<long double>& operator+=(long double);
    complex<long double>& operator-=(long double);
    complex<long double>& operator*=(long double);
    complex<long double>& operator/=(long double);
  
    template<class X> complex<long double>& operator= (const complex<X>&);
    template<class X> complex<long double>& operator+=(const complex<X>&);
    template<class X> complex<long double>& operator-=(const complex<X>&);
    template<class X> complex<long double>& operator*=(const complex<X>&);
    template<class X> complex<long double>& operator/=(const complex<X>&);
  
};
doc_CPP
doc_CPP
2025-01-10 15:47:30
Comments
Leave a Comment

Please login to continue.