How do i use more than 100.000 dot? - c

Question

I have made this Project it can calculate the Pi with the Monte-Carlo method, but if I use more than 100.000 dots it crashes. Does anyone know how to use like a 1.000.000 dots without crashing? I'm using the GNU compiler. I've tried with another compiler but I had the same problem.
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
int main() {
srand(time(NULL));
int dot;
int dotC = 0;
int dotS = 0;
printf("How many dot do you want to use?: ");
scanf("%d", &dot);
float pi[dot];
float x[dot];
float y[dot];
for (int i = 1; i < dot; i++) {
x[i] = (float)rand() / (float)RAND_MAX;
}
for (int i = 0; i < dot; i++) {
y[i] = (float)rand() / (float)RAND_MAX;
}
float distance[dot];
for (int i = 0; i < dot; ++i) {
distance[i] = sqrt(pow(x[i], 2) + pow(y[i], 2));
}
for (int i = 0; i < dot; ++i) {
if (distance[i] < 1) {
dotC++;
}
dotS++;
}
for (int i = 0; i < dot; ++i) {
pi[i] = (float)dotC / (float)dotS * 4;
}
printf("approximation of PY is: ");
printf("%f\n", pi[0]);
}

Answer 1

You get a stack overflow because you allocate large arrays with automatic storage (aka on the stack) exceeding the stack space available to your program.
You can fix the problem by allocating these from the heap with malloc() or calloc(), but you can simplify the algorithm by not using arrays at all:
for each random dot, compute the distance and update the dotC and dotS counters. No need to store the values.
the loop to initialize the x array should start at 0. You have undefined behavior as you do not initialize x[0].
dotS is actually redundant as its final value is the same as dot.
you should use double instead of float for increased precision.
you should use a simple multiplication instead of the more costly pow() function.
there is no need for sqrt() either: comparing the square of the distance to 1.0 gives the same result.
Here is a simplified version:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
srand(time(NULL));
int dots;
int dotC = 0;
printf("How many dots do you want to use?: ");
if (scanf("%d", &dots) != 1)
return 1;
for (int i = 0; i < dots; i++) {
double x = (double)rand() / (double)RAND_MAX;
double y = (double)rand() / (double)RAND_MAX;
if (x * x + y * y <= 1.0)
dotC++;
}
printf("approximation of PI is: %.9f\n", 4 * (double)dotC / (double)dots);
return 0;
}
On systems with slow floating point, you could change the for loop to use 64-bit integers and produce the same result:
for (int i = 0; i < dots; i++) {
long long x = rand();
long long y = rand();
if (x * x + y * y <= (long long)RAND_MAX * RAND_MAX)
dotC++;
}
This algorithm is really a benchmark of the pseudo random number generator, running it for 1 billion dots only produces 4 or 5 decimal places in 13 seconds on my old Macbook with the Apple libC. Integer or floating point versions run at the same speed on this CPU.

Answer 2

If you want dynamically allocated array, you should use malloc. Replace :
float *pi, *x, *y;
x = malloc(dot * sizeof(float));
if (x==NULL) {
printf("no memory for x\n");
exit(1);
}
y = malloc(dot * sizeof(float));
if (y==NULL) {
printf("no memory for y\n");
exit(1);
}
pi = malloc(dot * sizeof(float));
if (pi==NULL) {
printf("no memory for pi\n");
exit(1);
}
That would work, however, for big numbers, it would get out of memory. Perhaps you can calculate incremental? Why store all the calculation? Perhaps the algorithm is not clear enough to me, but I guess that should be possible...
I looked at your code again, and this seems to do the same:
int main(){
srand(time(NULL));
int dot;
int dotC = 0;
int dotS = 0;
printf("How mmany dot do you want to use?: ");
scanf("%d",&dot);
float pi, x, y;
for (int i = 0; i < dot ; i++){
x = (float)rand()/(float)RAND_MAX;
y = (float)rand()/(float)RAND_MAX;
if (sqrt(pow(x, 2) + pow(y, 2)) < 1)
{
dotC++;
}
dotS++;
}
printf("approximation of PY is: %f\n", dotC / (float)dotS * 4);
}

Answer 3

You are probably overflowing the stack (hence this website name) with the dynamic array allocations (like float distance[dot]) when dot is too large. To solve this, you can either increase the stack size (but you will encounter the same issue with larger numbers) or allocate your arrays on the heap instead, eg.
float * x = calloc(dot, sizeof(float));
float * y = calloc(dot, sizeof(float));
/* ... */
free(x);
free(y);
Checking calloc return values for NULL is usually recommended as well, see man calloc.

Answer 4

Well while the other answers are correct and more reasonable, you can always temporarily increase the stack size limit using the ulimit commands if you are on UNIX. This will allow for a few more decimals.
Get the currect stack size with ulimit -s or ulimit -a to get more info.
Then you can find the maximum size the stack can be by typing ulimit -H -s or ulimit -H -a for more info.
Finally you can set the stack size to the maximum by typing ulimit -s maxsize, maxsize is equal to the number you get when you type ulimit -H -s .
Stack size will reset to its default value when your terminate your shell.