Std::complex

1. Sablon:Label

A std::complex a C++ szabványos könyvtárban található osztály, amely komplex számok kezelésére szolgál. A komplex számok matematikai formája:

$$z=a+bi$$

ahol: - a a valós rész, - b az imaginárius rész, - i az egységnyi képzetes szám, ahol $i^2=-1$.

std::complex használata

Az std::complex osztály a <complex> fejlécben található. Használatához a következőket kell importálni:

#include <iostream>
#include <complex>

1. std::complex deklarálása és inicializálása

std::complex<double> z1(3.0, 4.0);  // 3 + 4i
std::complex<float> z2(1.5f, -2.5f); // 1.5 - 2.5i
std::complex<int> z3(2, 3); // Egész szám típusú komplex szám

A valós és képzetes részt konstruktorban adjuk meg.

2. Alapműveletek komplex számokkal

A std::complex osztály támogatja az alapműveleteket:

std::complex<double> a(1.0, 2.0);
std::complex<double> b(3.0, 4.0);

std::complex<double> sum = a + b;    // Összeadás
std::complex<double> diff = a - b;   // Kivonás
std::complex<double> prod = a * b;   // Szorzás
std::complex<double> quot = a / b;   // Osztás

std::cout << "Sum: " << sum << '\n';
std::cout << "Difference: " << diff << '\n';
std::cout << "Product: " << prod << '\n';
std::cout << "Quotient: " << quot << '\n';

A std::complex támogatja az operátorokat (+, -, *, /), így könnyen végezhetünk számításokat.

3. Komplex számok tulajdonságai

A komplex számok részei kiolvashatók:

std::complex<double> z(3.0, 4.0);
std::cout << "Real part: " << z.real() << '\n';
std::cout << "Imaginary part: " << z.imag() << '\n';

• real(): a valós részt adja vissza.
• imag(): az imaginárius részt adja vissza.

4. Hasznos matematikai függvények

A <complex> könyvtár számos matematikai függvényt tartalmaz:

#include <cmath>  // Szükséges a matematikai műveletekhez

std::complex<double> z(3.0, 4.0);

double magnitude = std::abs(z);  // A komplex szám abszolút értéke (|z| = sqrt(a² + b²))
double phase = std::arg(z);      // A komplex szám fázisszöge (rad)
std::complex<double> conjugate = std::conj(z); // Komplex konjugált (3 - 4i)
std::complex<double> exponential = std::exp(z); // e^(3+4i)

std::cout << "Magnitude: " << magnitude << '\n';
std::cout << "Phase angle: " << phase << '\n';
std::cout << "Conjugate: " << conjugate << '\n';
std::cout << "Exponential: " << exponential << '\n';

• std::abs(z): az abszolút értéket (magnitude) számolja ki.
• std::arg(z): a komplex szám fázisszögét adja vissza.
• std::conj(z): visszaadja a komplex konjugáltját.
• std::exp(z): a komplex exponenciális függvény.

5. Komplex számok exponenciális és trigonometrikus alakja

A komplex számok felírhatók poláris alakban:

$$z=r{e}^{i\theta }=r(\cos \theta +i\sin \theta )$$

C++-ban ezt így használhatjuk:

double magnitude = 5.0;
double angle = M_PI / 4; // 45 fok radianban

std::complex<double> polar_form = std::polar(magnitude, angle);
std::cout << "Polar form: " << polar_form << '\n';

• std::polar(magnitude, angle): egy komplex számot hoz létre poláris alakból.

6. Speciális függvények

A <complex> további speciális függvényeket is biztosít:

std::complex<double> z(1.0, 1.0);

std::complex<double> square_root = std::sqrt(z);  // Gyökvonás
std::complex<double> sine = std::sin(z);          // Szinusz
std::complex<double> cosine = std::cos(z);        // Koszinusz
std::complex<double> logarithm = std::log(z);     // Természetes alapú logaritmus

std::cout << "Square root: " << square_root << '\n';
std::cout << "Sine: " << sine << '\n';
std::cout << "Cosine: " << cosine << '\n';
std::cout << "Logarithm: " << logarithm << '\n';

• std::sqrt(z): gyökvonás komplex számon.
• std::sin(z), std::cos(z): trigonometrikus függvények.
• std::log(z): természetes alapú logaritmus.

7. Komplex számok összehasonlítása

Az std::complex nem támogatja közvetlenül az összehasonlító operátorokat (==, !=, <, >), mert a komplex számok rendezése nem értelmezhető egyértelműen. Azonban az egyenlőség ellenőrizhető:

std::complex<double> a(1.0, 2.0);
std::complex<double> b(1.0, 2.0);
std::complex<double> c(2.0, 3.0);

if (a == b) {
    std::cout << "a és b egyenlőek\n";
} else {
    std::cout << "a és b nem egyenlőek\n";
}

Az a == b csak akkor igaz, ha mind a valós, mind az imaginárius rész azonos.

8. Valós szám és komplex szám műveletei

Egy valós szám és egy komplex szám között a műveletek automatikusan működnek:

std::complex<double> z(2.0, 3.0);
double real_number = 5.0;

std::complex<double> result1 = z + real_number; // (7 + 3i)
std::complex<double> result2 = real_number * z; // (10 + 15i)

std::cout << "Result1: " << result1 << '\n';
std::cout << "Result2: " << result2 << '\n';

A valós számokat automatikusan átalakítja komplex számmá.

Összegzés

Az std::complex hasznos eszköz a komplex számok matematikai műveleteinek elvégzésére. A következőket nyújtja: - Alapvető műveletek (+, -, *, /) - Valós és imaginárius részek elérése - Speciális függvények (gyökvonás, logaritmus, trigonometrikus függvények) - Exponenciális és poláris alakok támogatása