`std::complex` în C++

Numere complexe (a + bi), cu operațiile aritmetice obișnuite, modul, argument și funcții matematice.

Sintaxă

std::complex<double> z(re, im);
z.real(), z.imag(), std::abs(z), std::arg(z), std::conj(z), std::polar(r, theta)

Ce face `std::complex`

std::complex<double> (din <complex>) reprezintă un număr a + bi. Operatorii + - * / funcționează direct. real() și imag() dau părțile, std::abs(z) modulul, std::arg(z) argumentul (unghiul), std::conj(z) conjugatul, iar std::polar(r, θ) creează un număr din formă polară.

Funcțiile std::sqrt, std::exp, std::pow au variante pentru numere complexe: std::sqrt(std::complex<double>(-9)) dă 3i (partea reală poate ieși un număr foarte mic în loc de 0, din cauza rotunjirilor). Cu using namespace std::complex_literals; poți scrie 3.0 + 4.0i. Afișarea cu std::println direct nu este disponibilă în C++23, așa că afișezi părțile separat sau folosești std::cout, care scrie numărul ca (real,imag).

Parametri

Parametru	Descriere
`re, im`	Partea reală și partea imaginară.

Ce returnează

Un obiect număr complex.

Exemple

Exemplul 1: Operații de bază

#include <complex>
#include <print>

void afiseaza(const char* nume, std::complex<double> z) {
    std::println("{} = {} {} {}i", nume, z.real(), z.imag() < 0 ? '-' : '+', std::abs(z.imag()));
}

int main() {
    std::complex<double> a(3, 4);
    std::complex<double> b(1, -2);

    afiseaza("a + b", a + b);
    afiseaza("a * b", a * b);
    afiseaza("conj(a)", std::conj(a));
    std::println("|a| = {}", std::abs(a));
}

Rezultat

a + b = 4 + 2i
a * b = 11 - 2i
conj(a) = 3 - 4i
|a| = 5

Exemplul 2: Rădăcina unui număr negativ și forma polară

#include <cmath>
#include <complex>
#include <iostream>
#include <numbers>
#include <print>

int main() {
    using namespace std::complex_literals;

    std::complex<double> r = std::sqrt(std::complex<double>(-9.0));
    std::println("sqrt(-9) = {:.4f} + {:.4f}i", r.real(), r.imag());
    std::cout << "Cu std::cout: " << std::complex<double>(3, 4) << '\n';

    std::complex<double> z = 1.0 + 1.0i;
    std::println("|z| = {:.4f}, arg = {:.1f}°", std::abs(z), std::arg(z) * 180 / std::numbers::pi);

    auto p = std::polar(2.0, std::numbers::pi / 2);
    std::println("polar(2, 90°) = {:.4f} + {:.4f}i", p.real(), p.imag());
}