ccomplex

---

1. Complex Number Operations

#include <complex>

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    std::cout << "z1 = " << z1 << ", z2 = " << z2 << std::endl;
    std::cout << "z1 + z2 = " << z1 + z2 << std::endl;
    std::cout << "z1 - z2 = " << z1 - z2 << std::endl;
    std::cout << "z1 * z2 = " << z1 * z2 << std::endl;
    std::cout << "z1 / z2 = " << z1 / z2 << std::endl;
}

2. Magnitude and Argument

#include <complex>
#include <cmath>

int main() {
    std::complex<double> z(3, 4);

    std::cout << "Magnitude: " << std::abs(z) << std::endl;
    std::cout << "Argument: " << std::arg(z) << std::endl;
}

3. Complex Exponentiation

#include <complex>
#include <cmath>

int main() {
    std::complex<double> z(1, 2), c(3, 4);

    std::cout << std::pow(z, c) << std::endl;
}

4. Complex Logarithm

#include <complex>
#include <cmath>

int main() {
    std::complex<double> z(1 + 2i);

    std::cout << std::log(z) << std::endl;
}

5. Complex Trigonometric Functions

#include <complex>
#include <cmath>

int main() {
    std::complex<double> z(1, 2);

    std::cout << std::sin(z) << std::endl;
    std::cout << std::cos(z) << std::endl;
    std::cout << std::tan(z) << std::endl;
}

6. Complex Conjugate

#include <complex>

int main() {
    std::complex<double> z(1, 2);

    std::cout << std::conj(z) << std::endl;
}

7. Complex Polar Form

#include <complex>

int main() {
    std::complex<double> z(3, 4);

    std::cout << std::polar(z) << std::endl;
}

8. Complex Comparison

#include <complex>

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    std::cout << (z1 == z2) << std::endl;
    std::cout << (z1 != z2) << std::endl;
}

9. Complex Assignment

#include <complex>

int main() {
    std::complex<double> z1(1, 2);
    std::complex<double> z2;

    z2 = z1;

    std::cout << z2 << std::endl;
}

10. Complex Arithmetic Expressions

#include <complex>

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    std::cout << ((z1 + z2) * (z1 - z2)) << std::endl;
}

11. Complex Array

#include <complex>
#include <array>

int main() {
    std::array<std::complex<double>, 5> z = {1 + 2i, 3 + 4i, 5 + 6i, 7 + 8i, 9 + 10i};

    for (auto& el : z) {
        std::cout << el << std::endl;
    }
}

12. Complex Vector

#include <complex>
#include <vector>

int main() {
    std::vector<std::complex<double>> z = {1 + 2i, 3 + 4i, 5 + 6i, 7 + 8i, 9 + 10i};

    for (auto& el : z) {
        std::cout << el << std::endl;
    }
}

13. Complex List

#include <complex>
#include <list>

int main() {
    std::list<std::complex<double>> z = {1 + 2i, 3 + 4i, 5 + 6i, 7 + 8i, 9 + 10i};

    for (auto& el : z) {
        std::cout << el << std::endl;
    }
}

14. Complex Set

#include <complex>
#include <set>

int main() {
    std::set<std::complex<double>> z = {1 + 2i, 3 + 4i, 5 + 6i, 7 + 8i, 9 + 10i};

    for (auto& el : z) {
        std::cout << el << std::endl;
    }
}

15. Complex Map

#include <complex>
#include <map>

int main() {
    std::map<std::string, std::complex<double>> z = {
        {"a", 1 + 2i},
        {"b", 3 + 4i},
        {"c", 5 + 6i},
        {"d", 7 + 8i},
        {"e", 9 + 10i}
    };

    for (auto& el : z) {
        std::cout << el.first << ": " << el.second << std::endl;
    }
}

16. Complex Function

#include <complex>

std::complex<double> f(std::complex<double> z) {
    return z * z;
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << f(z) << std::endl;
}

17. Complex Method

class Complex {
public:
    Complex(double real, double imag) : real(real), imag(imag) {}

    double getReal() const { return real; }
    double getImag() const { return imag; }

    Complex conjugate() const { return Complex(real, -imag); }

private:
    double real, imag;
};

int main() {
    Complex z(1, 2);

    std::cout << z.getReal() << ", " << z.getImag() << std::endl;
}

18. Complex Overload

#include <complex>

std::ostream& operator<<(std::ostream& os, const std::complex<double>& z) {
    os << "(" << z.real() << ", " << z.imag() << ")";
    return os;
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << z << std::endl;
}

19. Complex Equality Comparator

#include <complex>

bool operator==(const std::complex<double>& z1, const std::complex<double>& z2) {
    return z1.real() == z2.real() && z1.imag() == z2.imag();
}

int main() {
    std::complex<double> z1(1, 2), z2(1, 2);

    std::cout << (z1 == z2) << std::endl;
}

20. Complex Inequality Comparator

#include <complex>

bool operator!=(const std::complex<double>& z1, const std::complex<double>& z2) {
    return z1.real() != z2.real() || z1.imag() != z2.imag();
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    std::cout << (z1 != z2) << std::endl;
}

21. Complex Addition Assignment Operator

#include <complex>

std::complex<double>& operator+=(std::complex<double>& z1, const std::complex<double>& z2) {
    z1.real() += z2.real();
    z1.imag() += z2.imag();
    return z1;
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    z1 += z2;

    std::cout << z1 << std::endl;
}

22. Complex Subtraction Assignment Operator

#include <complex>

std::complex<double>& operator-=(std::complex<double>& z1, const std::complex<double>& z2) {
    z1.real() -= z2.real();
    z1.imag() -= z2.imag();
    return z1;
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    z1 -= z2;

    std::cout << z1 << std::endl;
}

23. Complex Multiplication Assignment Operator

#include <complex>

std::complex<double>& operator*=(std::complex<double>& z1, const std::complex<double>& z2) {
    z1.real() *= z2.real() - z2.imag();
    z1.imag() *= z2.real() + z2.imag();
    return z1;
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    z1 *= z2;

    std::cout << z1 << std::endl;
}

24. Complex Division Assignment Operator

#include <complex>

std::complex<double>& operator/=(std::complex<double>& z1, const std::complex<double>& z2) {
    double denom = z2.real() * z2.real() + z2.imag() * z2.imag();
    z1.real() = (z1.real() * z2.real() + z1.imag() * z2.imag()) / denom;
    z1.imag() = (z1.imag() * z2.real() - z1.real() * z2.imag()) / denom;
    return z1;
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    z1 /= z2;

    std::cout << z1 << std::endl;
}

25. Complex Unary Minus Operator

#include <complex>

std::complex<double> operator-(const std::complex<double>& z) {
    return std::complex<double>(-z.real(), -z.imag());
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << -z << std::endl;
}

26. Complex Unary Plus Operator

#include <complex>

std::complex<double> operator+(const std::complex<double>& z) {
    return z;
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << +z << std::endl;
}

27. Complex Pre-Increment Operator

#include <complex>

std::complex<double>& operator++(std::complex<double>& z) {
    z.real()++;
    z.imag()++;
    return z;
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << ++z << std::endl;
}

28. Complex Post-Increment Operator

#include <complex>

std::complex<double> operator++(std::complex<double>& z, int) {
    std::complex<double> tmp = z;
    z.real()++;
    z.imag()++;
    return tmp;
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << z++ << std::endl;
}

29. Complex Pre-Decrement Operator

#include <complex>

std::complex<double>& operator--(std::complex<double>& z) {
    z.real()--;
    z.imag()--;
    return z;
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << --z << std::endl;
}

30. Complex Post-Decrement Operator

#include <complex>

std::complex<double> operator--(std::complex<double>& z, int) {
    std::complex<double> tmp = z;
    z.real()--;
    z.imag()--;
    return tmp;
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << z-- << std::endl;
}

31. Complex Bitwise Not Operator

#include <complex>

std::complex<double> operator~(const std::complex<double>& z) {
    return std::complex<double>(~z.real(), ~z.imag());
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << ~z << std::endl;
}

32. Complex Bitwise And Operator

#include <complex>

std::complex<double> operator&(const std::complex<double>& z1, const std::complex<double>& z2) {
    return std::complex<double>(z1.real() & z2.real(), z1.imag() & z2.imag());
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    std::cout << (z1 & z2) << std::endl;
}

33. Complex Bitwise Or Operator

#include <complex>

std::complex<double> operator|(const std::complex<double>& z1, const std::complex<double>& z2) {
    return std::complex<double>(z1.real() | z2.real(), z1.imag() | z2.imag());
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    std::cout << (z1 | z2) << std::endl;
}

34. Complex Bitwise Xor Operator

#include <complex>

std::complex<double> operator^(const std::complex<double>& z1, const std::complex<double>& z2) {
    return std::complex<double>(z1.real() ^ z2.real(), z1.imag() ^ z2.imag());
}

int main() {
    std::complex<double> z1(1, 2), z2(3, 4);

    std::cout << (z1 ^ z2) << std::endl;
}

35. Complex Left Shift Operator

#include <complex>

std::complex<double> operator<<(const std::complex<double>& z, int shift) {
    return std::complex<double>(z.real() << shift, z.imag() << shift);
}

int main() {
    std::complex<double> z(1, 2);

    std::cout << (z << 2) << std::endl;
}

36. Complex Right Shift Operator

#include <complex>

std::complex<double> operator>>(const std::complex<double>& z, int shift) {
    return std::complex<double>(z.real() >> shift, z.imag() >> shift);
}

int main() {
    std::complex<double> z(1