Working with Polar Coordinates

Problem

You want to represent and manipulate polar coordinates.

Solution

The complex template from the header provides functions for conversion to and from polar coordinates. Example 11-34 shows how you can use the complex template class to represent and manipulate polar coordinates.

Example 11-34. Using complex template class to represent polar coordinates

#include 
#include 
 
using namespace std;

int main( ) {
 double rho = 3.0; // magnitude
 double theta = 3.141592 / 2; // angle
 complex coord = polar(rho, theta);
 cout << "rho = " << abs(coord) << ", theta = " << arg(coord) << endl;
 coord += polar(4.0, 0.0);
 cout << "rho = " << abs(coord) << ", theta = " << arg(coord) << endl;
}

Example 11-34 produces the following output:

rho = 3, theta = 1.5708
rho = 5, theta = 0.643501

 

Discussion

There is a natural relationship between polar coordinates and complex numbers. Even though the two are somewhat interchangeable, it is generally not a good idea to use the same type to represent different concepts. Since using the complex template to represent polar coordinates is inelegant, I have provided a polar coordinate class that is more natural to use in Example 11-35.

Example 11-35. A polar coordinate class

#include 
#include 

using namespace std;

template
struct BasicPolar
{
 public:
 typedef BasicPolar self;

 // constructors
 BasicPolar( ) : m( ) { }
 BasicPolar(const self& x) : m(x.m) { }
 BasicPolar(const T& rho, const T& theta) : m(polar(rho, theta)) { }

 // assignment operations
 self operator-( ) { return Polar(-m); }
 self& operator+=(const self& x) { m += x.m; return *this; }
 self& operator-=(const self& x) { m -= x.m; return *this; }
 self& operator*=(const self& x) { m *= x.m; return *this; }
 self& operator/=(const self& x) { m /= x.m; return *this; }
 operator complex( ) const { return m; }

 // public member functions
 T rho( ) const { return abs(m); }
 T theta( ) const { return arg(m); }

 // binary operations
 friend self operator+(self x, const self& y) { return x += y; }
 friend self operator-(self x, const self& y) { return x -= y; }
 friend self operator*(self x, const self& y) { return x *= y; }
 friend self operator/(self x, const self& y) { return x /= y; }

 // comparison operators
 friend bool operator==(const self& x, const self& y) { return x.m == y.m; }
 friend bool operator!=(const self& x, const self& y) { return x.m != y.m; }
 private:
 complex m;
};

typedef BasicPolar Polar;

int main( ) {
 double rho = 3.0; // magnitude
 double theta = 3.141592 / 2; // angle
 Polar coord(rho, theta);
 cout << "rho = " << coord.rho( ) << ", theta = " << coord.theta( ) << endl;
 coord += Polar(4.0, 0.0);
 cout << "rho = " << coord.rho( ) << ", theta = " << coord.theta( ) << endl;
 system("pause");
}

In Example 11-35, I have defined the Polar type as a typedef'd specialization of the BasicPolar template. This way you can have a convenient default but you can still specialize the BasicPolar template using another numerical type if you prefer. This technique is used in the standard library with the string class being a specialization of the basic_string template.