int main (int argc, char *argv[]) { int n; double wtime; long primes; printf ("Number of processors available = %d\n", omp_get_num_procs ( ) ); printf ("Number of threads = %d\n", omp_get_max_threads ( ) ); printf("\n\tn\t\tprime_num\ttime(second)\n"); n = 100000; omp_set_num_threads(NUM_THREAD); wtime = omp_get_wtime(); primes = prime_number(n); wtime = omp_get_wtime() - wtime; printf("\t%d\t\t%d\t\t%lf\n", n, primes, wtime); n = 500000; wtime = omp_get_wtime(); primes = prime_number(n); wtime = omp_get_wtime() - wtime; printf("\t%d\t\t%d\t\t%lf\n", n, primes, wtime); n = 1000000; wtime = omp_get_wtime(); primes = prime_number(n); wtime = omp_get_wtime() - wtime; printf("\t%d\t\t%d\t\t%lf\n", n, primes, wtime); return 0; }
/****************************************************************************** * PRIME_NUMBER_SWEEP does repeated calls to PRIME_NUMBER. * * @param n_lo - the first value of n * @param n_hi - the last value of n * @param n_factor - factor by which to increase n after each iteration * @return void */ void prime_number_sweep ( int n_lo, int n_hi, int n_factor ) { int i; int n; int primes; double wtime; struct timeval start,end; printf ( "\n Call PRIME_NUMBER to count the primes from 1 to N.\n" ); printf ( "\n" ); printf ( " N Pi Time\n" ); printf ( "\n" ); n = n_lo; while ( n <= n_hi ) { gettimeofday(&start,NULL); //Start timing the computation primes = prime_number ( n ); gettimeofday(&end,NULL); //Stop timing the computation wtime = (end.tv_sec+(double)end.tv_usec/1000000) - (start.tv_sec+(double)start.tv_usec/1000000); printf ( " %8d %8d %14f\n", n, primes, wtime ); n = n * n_factor; } return; }
void prime_number_sweep ( int n_lo, int n_hi, int n_factor ) /******************************************************************************/ { int i; int n; int primes; double wtime; printf ( "\n" ); printf ( "TEST01\n" ); printf ( " Call PRIME_NUMBER to count the primes from 1 to N.\n" ); printf ( "\n" ); printf ( " N Pi Time\n" ); printf ( "\n" ); n = n_lo; while ( n <= n_hi ) { wtime = omp_get_wtime ( ); primes = prime_number ( n ); wtime = omp_get_wtime ( ) - wtime; printf ( " %8d %8d %14f\n", n, primes, wtime ); n = n * n_factor; } return; }
void prime_number_sweep ( int n_lo, int n_hi, int n_factor ) /******************************************************************************/ /* Purpose: PRIME_NUMBER_SWEEP does repeated calls to PRIME_NUMBER. Licensing: This code is distributed under the GNU LGPL license. Modified: 06 August 2009 Author: John Burkardt Parameters: Input, int N_LO, the first value of N. Input, int N_HI, the last value of N. Input, int N_FACTOR, the factor by which to increase N after each iteration. */ { int i; int n; int primes; double ctime; printf ( "\n" ); printf ( "TEST01\n" ); printf ( " Call PRIME_NUMBER to count the primes from 1 to N.\n" ); printf ( "\n" ); printf ( " N Pi Time\n" ); printf ( "\n" ); n = n_lo; while ( n <= n_hi ) { ctime = cpu_time ( ); primes = prime_number ( n ); ctime = cpu_time ( ) - ctime; printf ( " %8d %8d %14f\n", n, primes, ctime ); n = n * n_factor; } return; }
int is_prime_number(int n){ if(n == 1){ return 0; } else if (n < 0){ return 0; } return prime_number(n, (n - 1)); /* This calls the recursive function */ }
int prime_number(int n, int i){ /* This is the recursive function */ if(i == 1){ /* When i reaches 1, then it means n is prime */ return 1; } else if (n % i == 0){ /* If n is divisible by any value of i */ return 0; } return prime_number(n, (i - 1)); }
int main ( int argc, char *argv[] ) /******************************************************************************/ /* Purpose: MAIN is the main program for PRIME_MPI. Discussion: This program calls a version of PRIME_NUMBER that includes MPI calls for parallel processing. Licensing: This code is distributed under the GNU LGPL license. Modified: 07 August 2009 Author: John Burkardt */ { int i; int id; int ierr; int n; int n_factor; int n_hi; int n_lo; int p; int primes; int primes_part; double wtime; n_lo = 1; n_hi = 262144; n_factor = 2; /* Initialize MPI. */ ierr = MPI_Init ( &argc, &argv ); /* Get the number of processes. */ ierr = MPI_Comm_size ( MPI_COMM_WORLD, &p ); /* Determine this processes's rank. */ ierr = MPI_Comm_rank ( MPI_COMM_WORLD, &id ); if ( id == 0 ) { timestamp ( ); printf ( "\n" ); printf ( "PRIME_MPI\n" ); printf ( " C/MPI version\n" ); printf ( "\n" ); printf ( " An MPI example program to count the number of primes.\n" ); printf ( " The number of processes is %d\n", p ); printf ( "\n" ); printf ( " N Pi Time\n" ); printf ( "\n" ); } n = n_lo; while ( n <= n_hi ) { if ( id == 0 ) { wtime = MPI_Wtime ( ); } ierr = MPI_Bcast ( &n, 1, MPI_INT, 0, MPI_COMM_WORLD ); primes_part = prime_number ( n, id, p ); ierr = MPI_Reduce ( &primes_part, &primes, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD ); if ( id == 0 ) { wtime = MPI_Wtime ( ) - wtime; printf ( " %8d %8d %14f\n", n, primes, wtime ); } n = n * n_factor; } /* Terminate MPI. */ ierr = MPI_Finalize ( ); /* Terminate. */ if ( id == 0 ) { printf ( "\n"); printf ( "PRIME_MPI - Master process:\n"); printf ( " Normal end of execution.\n"); printf ( "\n" ); timestamp ( ); } return 0; }
int main ( int argc, char *argv[] ) /******************************************************************************/ /* This program calls a version of PRIME_NUMBER that includes MPI calls for parallel processing. */ { int id; int ierr; int master = 0; int n; int n_factor; int n_hi; int n_lo; int p; int primes; int primes_part; double wtime; n_lo = 1; n_hi = 131072; n_factor = 2; //Initialize MPI. ierr = MPI_Init ( &argc, &argv ); //Get the number of processes. ierr = MPI_Comm_size ( MPI_COMM_WORLD, &p ); //Determine this processes's rank. ierr = MPI_Comm_rank ( MPI_COMM_WORLD, &id ); if ( id == master ) { timestamp ( ); printf ( "\n" ); printf ( "'PRIME_MPI\n" ); printf ( " An MPI example program to count the number of primes.\n" ); printf ( " The number of processes is %d\n", p ); } n = n_lo; while ( n <= n_hi ) { if ( id == master ) { wtime = MPI_Wtime ( ); } ierr = MPI_Bcast ( &n, 1, MPI_INT, master, MPI_COMM_WORLD ); primes_part = prime_number ( n, id, p ); ierr = MPI_Reduce ( &primes_part, &primes, 1, MPI_INT, MPI_SUM, master, MPI_COMM_WORLD ); if ( id == master ) { wtime = MPI_Wtime ( ) - wtime; } n = n * n_factor; } //Terminate MPI. ierr = MPI_Finalize ( ); //Terminate the main program if ( id == master ) { printf ( " Terminated.\n"); } return 0; }
/** * Set the dimension of the state space for a PNL_QMC rng * * @param rng a PnlRng * @param dim the dimension of the state space * @return OK or FAIL */ int pnl_rng_sdim (PnlRng *rng, int dim) { rng->counter=1; rng->has_gauss=0; rng->gauss=0.; rng->dimension = dim; if ( dim < 1 ) return FAIL; switch (rng->type) { case PNL_RNG_SQRT: { int i; sqrt_state *state; if ( dim > PNL_DIM_MAX_QMC ) return FAIL; state = (sqrt_state *)(rng->state); prime_number(rng->dimension, state->prime); for(i=0; i<rng->dimension; i++) { state->alpha[i]= sqrt((double) state->prime[i]); } } break; case PNL_RNG_HALTON: if ( dim > PNL_DIM_MAX_QMC ) return FAIL; prime_number(rng->dimension, ((halton_state *)(rng->state))->prime); break; case PNL_RNG_FAURE: { int prime[PNL_DIM_MAX_QMC]; faure_state *state; if ( dim > DIM_MAX_FAURE ) return FAIL; state = (faure_state *)(rng->state); binomial(FAURE_MAXI); if((rng->dimension == 2)||(rng->dimension == 1)) state->r= 3; else { prime_number(rng->dimension, prime); state->r=search_value(rng->dimension,prime,rng->dimension); } } break; case PNL_RNG_NIEDERREITER: { int i, j; nied_state *state; if ( dim > PNL_DIM_MAX_NIED ) return FAIL; state = (nied_state *)(rng->state); /* Initialization of initX_n[] */ for (i=1; i<=PNL_DIM_MAX_NIED; i++) state->initialX_n[i]= 0; state->facteur= 1.0/(double)(1UL << (BIT_MAX_NIED+1)); state->saut = 1L << 12; state->initial_d = state->saut; /* Gray code of saut */ state->gray = state->saut^(state->saut >> 1); for (i=0; i<=BIT_MAX_NIED; i++) { if (state->gray == 0) break; for (j= 1; j<= PNL_DIM_MAX_NIED; j++) { if ((state->gray & 1) == 0) break; /* XOR sum */ state->initialX_n[j] ^= NiedC[i][j]; } state->gray >>= 1; } } break; case PNL_RNG_SOBOL_I4: if ( dim > PNL_SOBOL_I4_DIM_MAX2) return FAIL; i4_sobol_init (rng, dim); break; case PNL_RNG_SOBOL_I8: if ( dim > PNL_SOBOL_I8_DIM_MAX2) return FAIL; i8_sobol_init (rng, dim); break; default: printf ("For PNL_MC rng, you shoud use pnl_rng_sseed instead of pnl_rng_sdim\n"); break; } return OK; }