Operacje na liczbach zespolonych w C++

Liczby zespolone są kluczowym elementem matematyki i inżynierii, znajdującym szerokie zastosowanie w analizie sygnałów, fizyce, elektrotechnice i wielu innych dziedzinach. W języku C++ standardowa biblioteka zawiera nagłówek <complex>, który umożliwia wykonywanie operacji na liczbach zespolonych w sposób efektywny i intuicyjny. Ta biblioteka oferuje wsparcie dla podstawowych i zaawansowanych operacji matematycznych, umożliwiając łatwą pracę z liczbami zespolonymi.

Podstawy liczb zespolonych w C++

Biblioteka <complex> w C++ definiuje szablon klasy std::complex, który reprezentuje liczby zespolone. Można używać tego szablonu z różnymi typami danych, takimi jak float, double i long double, aby uzyskać liczby zespolone o różnej precyzji.

Tworzenie liczb zespolonych

Liczby zespolone można tworzyć na różne sposoby, korzystając z konstruktora klasy std::complex lub przy użyciu operatora przypisania:

#include <iostream>
#include <complex>
int main() { // Tworzenie liczby zespolonej o wartościach domyślnych (0,0) std::complex<double> z1; // Tworzenie liczby zespolonej z częścią rzeczywistą i urojoną std::complex<double> z2(3.0, 4.0); // Tworzenie liczby zespolonej za pomocą przypisania std::complex<double> z3 = {5.0, -2.0}; std::cout << "z1 = " << z1 << std::endl; std::cout << "z2 = " << z2 << std::endl; std::cout << "z3 = " << z3 << std::endl; return 0;
}

Dostęp do części rzeczywistej i urojonej

Część rzeczywista i urojona liczby zespolonej w C++ mogą być uzyskane za pomocą metod real() i imag():

#include <iostream>
#include <complex>
int main() { std::complex<double> z(3.0, 4.0); // Dostęp do części rzeczywistej double realPart = z.real(); std::cout << "Część rzeczywista: " << realPart << std::endl; // Dostęp do części urojonej double imagPart = z.imag(); std::cout << "Część urojona: " << imagPart << std::endl; return 0;
}

Podstawowe operacje arytmetyczne

C++ obsługuje standardowe operacje arytmetyczne na liczbach zespolonych, takie jak dodawanie, odejmowanie, mnożenie i dzielenie. Można je wykonywać przy użyciu operatorów +, -, * i /:

#include <iostream>
#include <complex>
int main() { std::complex<double> z1(2.0, 3.0); std::complex<double> z2(1.0, -4.0); // Dodawanie std::complex<double> z_sum = z1 + z2; std::cout << "Suma: " << z_sum << std::endl; // Odejmowanie std::complex<double> z_diff = z1 - z2; std::cout << "Różnica: " << z_diff << std::endl; // Mnożenie std::complex<double> z_prod = z1 * z2; std::cout << "Iloczyn: " << z_prod << std::endl; // Dzielenie std::complex<double> z_div = z1 / z2; std::cout << "Iloraz: " << z_div << std::endl; return 0;
}

Zaawansowane operacje na liczbach zespolonych

C++ umożliwia także wykonywanie bardziej zaawansowanych operacji na liczbach zespolonych, takich jak obliczanie modułu, argumentu, sprzężenia zespolonego oraz operacje przy użyciu funkcji trygonometrycznych i wykładniczych.

Moduł i argument liczby zespolonej

Moduł liczby zespolonej to jej odległość od zera na płaszczyźnie zespolonej, a argument to kąt, jaki tworzy liczba zespolona z osią rzeczywistą. C++ oferuje funkcje std::abs() do obliczania modułu oraz std::arg() do obliczania argumentu:

#include <iostream>
#include <complex>
int main() { std::complex<double> z(1.0, 1.0); // Moduł liczby zespolonej double modulus = std::abs(z); std::cout << "Moduł: " << modulus << std::endl; // Argument liczby zespolonej double argument = std::arg(z); std::cout << "Argument: " << argument << " radiany" << std::endl; return 0;
}

Sprzężenie zespolone

Sprzężenie liczby zespolonej w C++ można uzyskać za pomocą funkcji std::conj():

#include <iostream>
#include <complex>
int main() { std::complex<double> z(2.0, -3.0); // Sprzężenie zespolone std::complex<double> z_conjugate = std::conj(z); std::cout << "Sprzężenie: " << z_conjugate << std::endl; return 0;
}

Funkcje trygonometryczne i wykładnicze

Biblioteka <complex> w C++ zawiera funkcje do obliczania wartości trygonometrycznych, wykładniczych i logarytmicznych dla liczb zespolonych:

#include <iostream>
#include <complex>
int main() { std::complex<double> z(1.0, 1.0); // Sinus liczby zespolonej std::complex<double> sin_z = std::sin(z); std::cout << "Sinus: " << sin_z << std::endl; // Kosinus liczby zespolonej std::complex<double> cos_z = std::cos(z); std::cout << "Kosinus: " << cos_z << std::endl; // Exponential liczby zespolonej std::complex<double> exp_z = std::exp(z); std::cout << "Exponential: " << exp_z << std::endl; return 0;
}

Przykładowe zastosowania liczb zespolonych w C++

W tej sekcji przedstawimy kilka przykładowych zastosowań liczb zespolonych w praktyce, aby lepiej zrozumieć, jak te operacje mogą być użyte w różnych dziedzinach.

Przykład 1: Rozwiązywanie równań kwadratowych z liczbami zespolonymi

Równania kwadratowe mogą mieć zespolone pierwiastki, gdy ich wyróżnik (delta) jest ujemny. Poniżej znajduje się implementacja rozwiązania równania kwadratowego w C++, które obsługuje liczby zespolone:

#include <iostream>
#include <complex>
int main() { double a = 1.0; double b = 2.0; double c = 5.0; std::complex<double> delta = std::sqrt(std::complex<double>(b * b - 4 * a * c)); // Oblicz dwa rozwiązania std::complex<double> x1 = (-b + delta) / (2.0 * a); std::complex<double> x2 = (-b - delta) / (2.0 * a); std::cout << "Pierwiastki równania to: " << x1 << " i " << x2 << std::endl; return 0;
}

Podsumowanie

Liczby zespolone w C++ są łatwe do użycia dzięki bibliotece <complex>, która oferuje szeroką gamę funkcji do pracy z tymi liczbami. Od podstawowych operacji arytmetycznych po zaawansowane funkcje trygonometryczne i wykładnicze, C++ umożliwia efektywną pracę z liczbami zespolonymi, co jest szczególnie użyteczne w aplikacjach inżynierskich i naukowych.