# ccomplex

***

**1. Complex Number Operations**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#include <complex>
#include <cmath>

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

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

**5. Complex Trigonometric Functions**

```cpp
#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**

```cpp
#include <complex>

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

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

**7. Complex Polar Form**

```cpp
#include <complex>

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

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

**8. Complex Comparison**

```cpp
#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**

```cpp
#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**

```cpp
#include <complex>

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

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

**11. Complex Array**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
#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

```