I have forgotten

Complex

Works with complex numbers where each component is of some specified type

Definition

The complex template class is defined in the standard header <complex>, and in the nonstandard backward-compatibility header <complex.h>.
```namespace std {
template <class T>
class complex;
}```
The template parameter `T` is used as the scalar type of both the real and the imaginary parts of the complex number.

Description

The template class `std::complex` operates on complex numbers.

A complex number is a number which can be put in the form `a + bi`, where `a` and `b` are real numbers and `i` is called the imaginary unit, where
$i^2&space;=&space;-1$

Complex Numbers Operations

Create, Copy, and Assign Operations

Operation Effect
complex c Creates a complex number with 0 as the real part and 0 as the imaginary part
complex c(1.1) Creates a complex number with 1.1 as the real part and 0 as the imaginary part
complex c(1.1,2.2) Creates a complex number with 1.1 as the real part and 1.2 as the imaginary part
complex c1(c2) Creates `c1` as a copy of `c2`
polar (2. 2) Creates a temporary complex number from polar coordinates (2.2 as magnitude rho and 0 as phase angle theta)
polar (2. 2, 0.77) Creates a temporary complex number from polar coordinates (2.2 as magnitude rho and 0.77 as phase angle theta)
conj (c) Creates a temporary complex number that is the conjugated complex number of `c`
c1 = c2 Assigns the values of `c2` to `c1`
c1 += c2 Adds the value of `c2` to `c1`
c1 -= c2 Subtracts the value of `c2` from `c1`
c1 *= c2 Multiplies the value of `c2` by `c1`
c1 /= c2 Divides the value of `c2` into `c1`

Value Access

Operation Effect
c.real() Returns the value of the real part (member function)
real(c) Returns the value of the real part (global function)
c.imag() Returns the value of the imaginary part (member function)
imag(c) Returns the value of the imaginary part (global function)
abs(c) Returns the absolute value of `c`
norm(c) Returns the squared absolute value of c(c.real()^2 + c.imag()^2)
arg(c) Returns the angle of the polar representation of `c`

Comparison Operations

Operation Effect
c1 == c2 Returns if `c1` is equal to `c2`
c1 != c2 Returns if `c1` differs from `c2`

Arithmetic Operations

Operation Effect
c1 + c2 Returns the sum of `c1` and `c2`
c1 - c2 Returns the difference between `c1` and `c2`
c1 * c2 Returns the product of `c1` and `c2`
c1 / c2 Returns the quotient of `c1` and `c2`
-c Returns the negated value of `c`
+ c Returns `c`
c1 += c2 Same with c1 = c1 + c2
c1 -= c2 Same with c1 = c1 - c2
c1 *= c2 Same with c1 = c1 * c2
c1 /= c2 Same with c1 = c1 / c2

Input/Output Operations

Operation Effect
strm << c Writes the complex number `c` to the ostream `strm`
strm >> c Reads the complex number `c` from the istream `strm`

Transcendental Functions

Operation Effect
pow(c1, c2) Complex power c1^c2
exp(c) Base `e` exponential of `c` (e^c)
sqrt(c) Square root of `c`
log(c) Complex natural logarithm of `c` with base `e` (`ln c`)
log10(c) Complex common logarithm of `c` with base `10` (`lg c`)
sin(c) Sine of `c`
cos(c) Cosine of `c`
tan(c) Tangent of `c`
sinh(c) Hyperbolic sine of `c`
cosh(c) Hyperbolic cosine of `c`
tanh(c) Hyperbolic tangent of `c`

References:

• Nicolai M. Josuttis: "The C++ Standard Library"

Example:
Example - Complex numbers
Problem
The following program performs some common operations on complex numbers.
Workings
```#include <iostream>
#include <complex>
using namespace std;

int main()
{
/*complex number with real and imaginary parts
*-real part: 4.0
*-imaginary part: 3.0
*/
complex<double> c1(4.0,3.0);

/*create complex number from polar coordinates
*-magnitude:5.0
*-phase angle:0.75
*/
complex<float> c2(polar(5.0,0.75));

// print complex numbers with real and imaginary parts
cout << "c1: " << c1 << endl;
cout << "c2: " << c2 << endl;

//print complex numbers as polar coordinates
cout << "c1: magnitude: " << abs (c1)
<< " (squared magnitude: " << norm(c1) << ") "
<< " phase angle: " << arg(c1) << endl;
cout << "c2: magnitude: " << abs(c2)
<< " (squared magnitude: " << norm (c2) << ") "
<< " phase angle: " << arg(c2) << endl;

//print complex conjugates
cout << "c1 conjugated: " << conj(c1) << endl;
cout << "c2 conjugated: " << conj(c2) << endl;

//print result of a computation
cout << "4.4 + c1 * 1.8: " << 4.4 + c1 * 1.8 << endl;

/*print sum of c1 and c2:
*-note: different types
*/
cout << "c1 + c2:        "
<< c1 + complex<double>(c2.real(),c2.imag()) << endl;

// add square root of c1 to c1 and print the result
cout << "c1 += sqrt(c1): " << (c1 += sqrt(c1)) << endl;

return 0;
}```
Solution
Output:

c1: (4,3)
c2: (3.65844,3.40819)
c1: magnitude: 5 (squared magnitude: 25) phase angle: 0.643501
c2: magnitude: 5 (squared magnitude: 25) phase angle: 0.75
c1 conjugated: (4,-3)
c2 conjugated: (3.65844,-3.40819)
4.4 + c1 * 1.8: (11.6,5.4)
c1 + c2: (7.65844,6.40819)
c1 += sqrt(c1): (6.12132,3.70711)
References
• Nicolai M. Josuttis: "The C++ Standard Library"