std::polar function in C++

Introduction

As it pertains to programming in C++, the Standard Template Library (STL) has various features meant to assist in the manipulation of complex numbers and their relations. Of these subtitles, the std::polar function stands out as one of the most helpful since it is designed to convert a polar coordinate representation of a number into its corresponding complex number. Polar coordinates enable the representation of a point by two figures: the radial coordinate or radius (magnitude) and the angular coordinate or angle (phase). Such geometrical representation helps in signal processing, physics, and engineering, among other physical and mathematical uses.

In this article, we will be concentrating on the std::polar function, its usage, and syntactical representations and presenting some sample codes supporting the conversion of polar coordinates in C++.

Problem Statement

Various mathematical and engineering systems are based on the utilization of complex numbers in a polar format such that a distinct region of the complex space can be defined using two numbers:

• r (or simply radius): It implies how far the point is from the origin.
• θ (or simply phase): It means the angle reserved between the point and the x-axis and is measured clockwise from the full x-axis positive direction.

However, it should be noted that in C++, there are no facilities to work with a polar coordinate system involving complex numbers. For this reason, any time there is the need to use complex numbers in C++, it requires transforming the polar coordinates into the usual rectangular form (real and imaginary parts).

The std::polar function has a unique and standard approach for changing points from polar to a complex unit without the need to specify the real and imaginary indices separately.

The polar function

The std::polar function comes from the cluster-templated class in the library in C++. It is a function that enables the formulation of a complex number using polar coordinates. The function can be expressed in general as:

• r: It refers to the size (radial) of the complex number.
• theta: It refers to the angle of phase shift in radians relative to the horizontal side of the x-axis. If it is omitted, it becomes 0.0.

The resultant of this function is std::complex, which is basically in the form of a complex number a+bi where b is real and a is the imaginary number. Real and imaginary parties are derived from polar coordinates as:

Main Importances of polar function:

• This feature has simplified the process of determining the real and imaginary parts of the number with the use of trigonometric functions.
• It has maintained the correctness as the conversion is performed in double precision floating point in the background.
• The default value for the angle makes the case that there is only an amount supplied easier in that there is no provision for both the angle and the amount.

Program 1:

Output:

 
Complex number (Cartesian form): (3.53553,3.53553)
Real part: 3.53553
Imaginary part: 3.53553   

Explanation:

1. r = 5.0: It is the magnitude of the complex number.
2. theta = M_PI / 4.0: It is the angle (in radians) equivalent to 45 degrees.
3. The std::polar(r, theta) converts the polar coordinates (r, θ) into a complex number (real, imaginary).
4. The result is printed, where both the real and imaginary parts are approximately 3.5355.

Time and Space Complexities:

Time Complexity: O(1)

• Constant time for std::polar and std::cout operations.

Space Complexity: O(1)

• Fixed space for r, theta, and the complex number.

Program 2:

Output:

 
Complex number (Cartesian form): (4,0)   

Explanation:

1. r = 4.0: This is the magnitude.
2. The std::polar(r) uses the default angle θ = 0, so the resulting complex number is purely real (4 + 0i).
3. The output shows the real part as 4, and the imaginary part as 0.

Time and Space Complexities:

Time Complexity: O(1)

• The std::polar function and printing the result both take constant time.

Space Complexity: O(1)

• Fixed space for the magnitude (r) and the complex number. No dynamic memory allocation.

Advanced Testing Features

• While utilizing the std::polar function, a few edge cases must also be taken into account: Assuming a Negative Radius: Depending on the dimension, the negative radius may pose some undesired outcomes since the ratio is usually regarded as a positive number. It's advisable to avoid r< 0 in your code unless you're assuming unconventional definitions.
• Precision Issues: Because of the nature of numbers, the rounding of a very tiny or large magnitude value or even an angle should be avoided, which may apparently appear in this formulation. C++ handles this quite well and comfortably for most practical applications, but still, this is something that has to be kept in mind while dealing with very extreme values.

Program 3:

Output:

 
Complex numbers (Cartesian form):
Complex number 1: (2.59808,1.5)
Complex number 2: (2.82843,2.82843)
Complex number 3: (2.5,4.33013)
Complex number 4: (3.67394e-16,6)
Complex number 5: (-7,8.57253e-16)

Sum of all complex numbers: (0.926503,14.6586)
Product of all complex numbers: (1781.91,1781.91)   

Explanation:

1. Array of Complex Numbers: We introduce two arrays, which are the magnitudes and the angles, where the magnitude and the angle join to have denoted in polar coordinates.
2. Creating Complex Numbers: A loop is employed where, for each set of polar coordinates, a respective complex number is formed with std::polar.
3. Displaying Cartesian Form: The resultant complex numbers are brought out in Cartesian form.
4. Sum and Product: The sum of all the complex numbers and the product of all those complex numbers are computed, showing how manipulations can be done with complex numbers in C++.

Time and Space Complexities:

Time Complexity: O(n)

• Loops for creating, displaying, summing, and multiplying complex numbers each run n times.

Space Complexity: O(n)

• Arrays for magnitudes, angles, and complex numbers each take space proportional to n.

Program 4:

Output:

 
Input Signal (Time Domain):
x(0) = (1,0)
x(1) = (2,0)
x(2) = (3,0)
x(3) = (4,0)

DFT Result (Frequency Domain, Cartesian Form):
X(0) = (10,0)
X(1) = (-2,2)
X(2) = (-2,-9.79717e-16)
X(3) = (-2,-2)

DFT Result in Polar Form (Magnitude, Phase in Radians):
X(0): Magnitude = 10, Phase = 0 radians
X(1): Magnitude = 2.82843, Phase = 2.35619 radians
X(2): Magnitude = 2, Phase = -3.14159 radians
X(3): Magnitude = 2.82843, Phase = -2.35619 radians   

Explanation:

1. Input Signal:
   
   • A signal in the time domain is called the inputSignal and can be represented as a vector of complex numbers. Basically, all of these values are usually (1.0, 2.0, 3.0, and 4.0), but the DFT works for complex values as well.
2. Discrete Fourier Transform (DFT):
   

Time and Space Complexities:

Time Complexity: O(N²)

• For each frequency bin k, the inner loop, computing a summation, goes through N iterations, and there are N frequency bins. Hence, the time complexity is O(N²).

Space Complexity: O(N)

• The input signal, DFT result, sum, and the intermediate variable expTerm occupy space of order N. Hence, the space complexity is O(N).

Conclusion

In conclusion, the std::polar function is a powerful function available to C++ programmers in the conversion of polar coordinates to complex numbers, which in turn makes it easy to work with the complex numbers in mathematical engineering. The convenience of this function is that it derives actual and thematic components without splitting them from the modulus and phase, thereby reducing the work of the developers.

Using std::polar allows C++ programmers to go beyond C++ and seamlessly transition between polar and Cartesian coordinates of complex numbers and conveniently perform complex calculations in several areas.