### Finding equidistant points on a circle

We know that every circle has $$360\degree = 2\pi$$. It’s what makes them round.
How can we find the (x,y) positions of n that are evenly distributed on a circle?

Trigonometry to the rescue! All points on a circle are equidistant to the circle’s center. All we need to do is go around the circle evenly so that we arrive where we started after n steps.

For this, we put each point at an angle $$\theta$$ that goes from 360/n to 360 evenly in n steps:

$$\theta = \frac{1}{n} \cdot 360,;; \frac{2}{n} \cdot 360,;; \ldots,;; \frac{n}{n} \cdot 360$$

Then we must know that a point (x,y) at an angle $$\theta$$ is located at

$$(x,y) = (x_0 + r \cdot cos(\theta), y_0 + r \cdot sin(\theta))$$

where $$x_0, y_0$$ are the center of the circle and $$r$$ is the circle’s radius.

So calculate $$(x,y)$$ for all $$\theta$$ and you’re all set!
For simplicity’s sake, here is some C++ code that does exactly this and also computes pairwise distances:

#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <vector>

using namespace std;

class Coord {
public:
Coord(double x, double y) : x(x), y(y) {}
double x, y;

double distance(const Coord& other) const {
return sqrt(pow(x - other.x, 2) + pow(y - other.y, 2));
}

};

int main(int argc, char** argv) {
if (argc < 5) {
cerr << "I need parameters: <circle center x> <circle center y> <radius> <number of points>" << endl;
exit(-1);
}
centerX = atof(argv[2]),
centerY = atof(argv[3]),
numPoints = atof(argv[4]);
cout << "Plotting " << numPoints << " equidistant points on a circle with center (x=" << centerX << ", y=" << centerY

vector<Coord> coords;
for (double i = 0; i < numPoints; i++) {
double angle = (2 * M_PI) * ((i+1) / numPoints); // For all points the angles sum to 360 degrees = 2Pi.
double x = centerX + radius * cos(angle);
double y = centerY + radius * sin(angle);
coords.push_back(Coord(x, y));
}

// Print them.
cout << "P\tx\ty" << endl;
for (size_t i = 0; i < coords.size(); i++) {
cout << (i+1) << "\t" << coords.at(i).x << "\t" << coords.at(i).y << endl;
}

// Print pairwise distances.
for (size_t i = 0; i < coords.size(); i++) {
for (size_t j = 0; j < coords.size(); j++) {
cout << "d(" << (i+1) << ", " << (j+1) << ") = " << coords.at(i).distance(coords.at(j)) << endl;
}
}
return 0;
}


For n=6, x0=800, y0=300, r=200 we find:

P	x	y
1	900	473.205
2	700	473.205
3	600	300
4	700	126.795
5	900	126.795
6	1000	300
d(1, 1) = 0
d(1, 2) = 200
d(1, 3) = 346.41
d(1, 4) = 400
d(1, 5) = 346.41
d(1, 6) = 200
d(2, 1) = 200
d(2, 2) = 0
d(2, 3) = 200
d(2, 4) = 346.41
d(2, 5) = 400
d(2, 6) = 346.41
d(3, 1) = 346.41
d(3, 2) = 200
d(3, 3) = 0
d(3, 4) = 200
d(3, 5) = 346.41
d(3, 6) = 400
d(4, 1) = 400
d(4, 2) = 346.41
d(4, 3) = 200
d(4, 4) = 0
d(4, 5) = 200
d(4, 6) = 346.41
d(5, 1) = 346.41
d(5, 2) = 400
d(5, 3) = 346.41
d(5, 4) = 200
d(5, 5) = 0
d(5, 6) = 200
d(6, 1) = 200
d(6, 2) = 346.41
d(6, 3) = 400
d(6, 4) = 346.41
d(6, 5) = 200
d(6, 6) = 0