How to generate a set of points that are equidistant from each other and lie on a circle

I am trying to generate an array of n points that are equidistant from each other and lie on a circle in C. Basically, I need to be able开发者_如何学运维 to pass a function the number of points that I would like to generate and get back an array of points.

It's been a really long time since I've done C/C++, so I've had a stab at this more to see how I got on with it, but here's some code that will calculate the points for you. (It's a VS2010 console application)

// CirclePoints.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "stdio.h"
#include "math.h"

int _tmain()
{
    int points = 8;
    double radius = 100;

    double step = ((3.14159265 * 2) / points);
    double x, y, current = 0;
    for (int i = 0; i < points; i++)
    {
        x = sin(current) * radius;
        y = cos(current) * radius;

        printf("point: %d x:%lf y:%lf\n", i, x, y);

        current += step;
    }

    return 0;
}

Try something like this:

void make_circle(float *output, size_t num, float radius)
{
  size_t i;

  for(i = 0; i < num; i++)
  {
    const float angle = 2 * M_PI * i / num;
    *output++ = radius * cos(angle);
    *output++ = radius * sin(angle);
  }
}

This is untested, there might be an off-by-one hiding in the angle step calculation but it should be close.

This assumes I understood the question correctly, of course.

UPDATE: Redid the angle computation to not be incrementing, to reduce float precision loss due to repeated addition.

Here's a solution, somewhat optimized, untested. Error can accumulate, but using double rather than float probably more than makes up for it except with extremely large values of n.

void make_circle(double *dest, size_t n, double r)
{
    double x0 = cos(2*M_PI/n), y0 = sin(2*M_PI/n), x=x0, y=y0, tmp;
    for (;;) {
        *dest++ = r*x;
        *dest++ = r*y;
        if (!--n) break;
        tmp = x*x0 - y*y0;
        y = x*y0 + y*x0;
        x = tmp;
    }
}

You have to solve this in c language:

In an x-y Cartesian coordinate system, the circle with centre coordinates (a, b) and radius r is the set of all points (x, y) such that

(x - a)^2 + (y - b)^2 = r^2

Here's a javascript implementation that also takes an optional center point.

function circlePoints (radius, numPoints, centerX, centerY) {
  centerX = centerX || 0;
  centerY = centerY || 0;

  var
    step = (Math.PI * 2) / numPoints,
    current = 0,
    i = 0,
    results = [],
    x, y;

  for (; i < numPoints; i += 1) {
    x = centerX + Math.sin(current) * radius;
    y = centerY + Math.cos(current) * radius;

    results.push([x,y]);

    console.log('point %d @ x:%d, y:%d', i, x, y);

    current += step;
  }

  return results;
}