CS Knowledge Base

Этот заголовок является частью numeric библиотеки.

Классы

complex	a complex number type (шаблон класса)
`complex`<float>`complex`<double>`complex`<long double>	a complex number type (специализация шаблона класса)

Функции

Операции
operator+operator-	применяет унарные операторы к комплексным числам (шаблон функции)
operator+operator-operator*operator/	выполняет арифметику комплексных чисел над двумя комплексными значениями или комплексным и скалярным значениями (шаблон функции)
operator==operator!= (удалено в C++20)	сравнивает два комплексных числа или комплексное и скалярное числа (шаблон функции)
operator<<operator>>	сериализует и десериализует комплексное число (шаблон функции)
real	возвращает действительную часть (шаблон функции)
imag	возвращает мнимую часть (шаблон функции)
abs(std::complex)	возвращает величину комплексного числа (шаблон функции)
arg	возвращает угол фазы (шаблон функции)
norm	возвращает квадрат величины (шаблон функции)
conj	возвращает комплексное сопряжение (шаблон функции)
proj (C++11)	возвращает проекцию на сферу Римана (шаблон функции)
polar	создаёт комплексное число из величины и угла фазы (шаблон функции)
Экспоненциальные функции
exp(std::complex)	комплексная экспонента по основанию e (шаблон функции)
log(std::complex)	комплексный натуральный логарифм с ветвью, обрезанной по отрицательной действительной оси (шаблон функции)
log10(std::complex)	комплексный десятичный логарифм с ветвью, обрезанной по отрицательной действительной оси (шаблон функции)
Степенные функции
pow(std::complex)	комплексная степень, один или оба аргумента могут быть комплексным числом (шаблон функции)
sqrt(std::complex)	комплексный квадратный корень из диапазона правой полуплоскости (шаблон функции)
Тригонометрические функции
sin(std::complex)	вычисляет синус комплексного числа (${\small\sin{z} }$ $sin(z)$ ) (шаблон функции)
cos(std::complex)	вычисляет косинус комплексного числа (${\small\cos{z} }$ $cos(z)$ ) (шаблон функции)
tan(std::complex)	вычисляет тангенс комплексного числа (${\small\tan{z} }$ $tan(z)$ ) (шаблон функции)
asin(std::complex) (C++11)	вычисляет арксинус комплексного числа (${\small\arcsin{z} }$ $arcsin(z)$ ) (шаблон функции)
acos(std::complex) (C++11)	вычисляет арккосинус комплексного числа (${\small\arccos{z} }$ $arccos(z)$ ) (шаблон функции)
atan(std::complex) (C++11)	вычисляет арктангенс комплексного числа (${\small\arctan{z} }$ $arctan(z)$ ) (шаблон функции)
Гиперболические функции
sinh(std::complex)	вычисляет гиперболический синус комплексного числа (${\small\sinh{z} }$ $sinh(z)$ ) (шаблон функции)
cosh(std::complex)	вычисляет гиперболический косинус комплексного числа (${\small\cosh{z} }$ $cosh(z)$ ) (шаблон функции)
tanh(std::complex)	вычисляет гиперболический тангенс комплексного числа (${\small\tanh{z} }$ $tanh(z)$ ) (шаблон функции)
asinh(std::complex) (C++11)	вычисляет гиперболический синус площади комплексного числа (${\small\operatorname{arsinh}{z} }$ $arsinh(z)$ ) (шаблон функции)
acosh(std::complex) (C++11)	вычисляет гиперболический косинус площади комплексного числа (${\small\operatorname{arcosh}{z} }$ $arcosh(z)$ ) (шаблон функции)
atanh(std::complex) (C++11)	вычисляет гиперболический тангенс площади комплексного числа (${\small\operatorname{artanh}{z} }$ $artanh(z)$ ) (шаблон функции)
Литералы
operator""ifoperator""ioperator""il (C++14)	литерал std::complex, представляющий чисто мнимое число (функция)

Краткое содержание

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);
        }
    }
}

Класс 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 специализации

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>&);
};

Отчеты об ошибках

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 79	C++98	the default argument of the second parameter of `polar` was missing in the synopsis	added

Поддержка компилятором
Автономные и размещённые реализации
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Требования к именованию
Макросы тестирования функциональности (C++20)
Поддержка языка
Библиотека концептов (C++20)
Библиотека метапрограммирования (C++11)
Библиотека диагностики
Библиотека общих утилит
Библиотека строк
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека численных данных
Библиотека ввода/вывода
Библиотека локализаций
Регулярные выражения (C++11)
Атомарные операции (C++11)
Библиотека поддержки конкуренции (C++11)
Библиотека файловой системы (C++17)
Технические спецификации
Указатель символов
Внешние библиотеки

CS Knowledge Base

cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

Содержание

Классы

Функции

Операции

Экспоненциальные функции

Степенные функции

Тригонометрические функции

Гиперболические функции

Литералы

Краткое содержание

Класс std::complex

std::complex специализации

Отчеты об ошибках

Навигация

Инструменты