ab

b

/*
5.5. Feladatok
1. (
 ) A π értéke pontosan becsülhet ̋ o un. Monte Carlo integrálás segítségével. A megkö-
zelítés alapja, hogy az egység sugarú kör területe éppen T k = π, míg a két egység oldal-
T k π T khosszúságú négyzet területe T n = 4, a kett ̋ o aránya T n = 4 . A T n arányt úgy becsülhetjük,
hogy egyenletes eloszlású N darab véletlen számpárt generálunk a [−1, 1] × [−1, 1] inter-
vallumban, és megszámoljuk, hogy ezek közül hány darab esik az egységkörbe, azaz hány
(x, y) pontpárra teljesül, hogy x2 + y2 ≤ 1. Legyen a körbe es ̋ o pontok száma K. Ekkor π
értéke π ˆ = 4 K módon közelíthet ̋ o. Készítsen programot, amely π értékének közelítésé-
Nre használható, egyenletes eloszlású pontpárok generálásához használja a GSL5 csomag
gsl_rng_uniform függvényét!
A végrehajtás során használt P darab szál mindegyike generáljon N véletlen számpárt, re-
gisztrálják az egységkörbe es ̋ o koordináta párok számát saját K változójukba, majd össze-
gezzék a K értékeket a szálak által közösen elérhet ̋ o memóriaterületen, úgy, hogy az a
szálak befejez ̋ odése utána f ̋ oprogram által elérhet ̋ o legyen. Az összegzett K értékb ̋ ol a
K
f ̋ oprogram számítja ki π közelít ̋ o értékét a 4 formula alapján.
PN
A következ ̋ o párhuzamos implementációkat készítse el:
4 
*/

//gcc -O3 -Wall -pedantic -fopenmp main.c
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <sys/time.h>
#include <omp.h>

//#include "gsl/gsl_math.h"
/*
#define RNG_MOD 0x80000000
int state;
int rng_int(void);
double rng_doub(double range);
int main()
{
    int i, numIn, n;
    double x, y, pi;
    n = 1<<30;
    numIn = 0;
    #pragma omp threadprivate(state)
    #pragma omp parallel private(x, y) reduction(+:numIn) 
    {

        state = 25234 + 17 * omp_get_thread_num();
        #pragma omp for
        for (i = 0; i <= n; i++) {
            x = (double)rng_doub(1.0);
            y = (double)rng_doub(1.0);
            if (x*x + y*y <= 1) numIn++;
        }
    }
    pi = 4.*numIn / n;
    printf("asdf pi %f\n", pi);
    return 0;
}
int rng_int(void) {
   // & 0x7fffffff is equivalent to modulo with RNG_MOD = 2^31
   return (state = (state * 1103515245 + 12345) & 0x7fffffff);
}
double rng_doub(double range) {
    return ((double)rng_int()) / (((double)RNG_MOD)/range);
}
*/
/*
void main()
{
	double PI; // PI értéke
	int N; // N darab számpár
	int K; // körbe eső pontok száma
	int P; // szálak száma
	int i, j; // futóváltozó
	gsl_rng *r;
	printf("Kérem, adja meg a szálak számát (P): ");
	scanf("%d", &P);
	printf("Kérem, adja meg a számpárok számát (N): ");
	scanf("%d", &N);
	double szamparok[2][N*P];
	#pragma omp parallel
	{
		#pragma omp for
		for(i=0; i<N; i++)
		{
			
		}
	}
	
	  for(i=0; i<2; i++){
   for(j=0; j<(N*P); j++){
     szamparok[i][j]=gsl_rng_uniform(r);
     printf("%.5f\n", szamparok[i][j]);
   }
	
	return;
}
*/
 

typedef struct Koordinatak{
  double x;
  double y;
} Koordinata;



int main(){

	
	FILE *file;
	file = fopen("results.dat", "a");
int r=0;	
	int n = 0;
  int p = 0;
  int i = 0;
  int j = 0;
  int k=0;
  int osszes;
  //gsl_rng *r;
  //const gsl_rng_type *T;
  
  
  /*
   CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(MonteCarlo-PI_OpenMP C)
SET(TARGET_NAME MonteCarlo-PI_OpenM)
AUX_SOURCE_DIRECTORY(. SRC)
ADD_EXECUTABLE(${TARGET_NAME} ${SRC})
SET(CMAKE_C_FLAGS "-fopenmp")
SET(CMAKE_VERBOSE_MAKEFILE on)
   
   */
  
  
	double t1, t2, ttotal=0;
  
  
  //printf("Kerem adja meg a szalak szamat: ");
  //scanf("%d", &n);
  printf("Kerem adja meg a szalankent generalt szamparok szamat: ");
  scanf("%d", &p);
  
  //T = gsl_rng_default;
  //r = gsl_rng_alloc (T);
  
#pragma omp
  for(n=100; n<=1000; n=n+100)
  {
	osszes=n*p;
	Koordinata szampar[osszes];
  
	t1 = omp_get_wtime();
	#pragma omp parallel num_threads(n) private(ttotal)
	{
		#pragma omp for schedule(dynamic) private(i)
		for(i=0; i<osszes; i++)
		{
			//#pragma omp atomic
			szampar[i].x = (rand()%100000);
			//#pragma omp atomic
			szampar[i].x = szampar[i].x/100000;
			//#pragma omp atomic
			szampar[i].y = (rand()%100000);
			//#pragma omp atomic
			szampar[i].y = szampar[i].y/100000;
		}
		#pragma omp for schedule(dynamic)
		for(i=0; i<osszes; i++)
		{
			if((szampar[i].x*szampar[i].x)+(szampar[i].y*szampar[i].y) <= 1)
			{
				#pragma omp atomic
				k+=1;
			}
		}
		t2 = omp_get_wtime();
	}
	ttotal += (t2-t1);
	printf("szálidő: %f\n", ttotal);
	printf("átlag idő: %f\n", ttotal/n);
	float pikozel=4*((float)k/(p*n));
	k=0;
	fprintf(file, "%f\t%d\n", ttotal, r++); // write summary to results file
	printf("A pi kozelitese %d szallal, szalankent %d szamparral: %.8f\n", n, p, pikozel);
	#pragma omp barrier
  }
  
  
return 0; 
}