int main (int argc, char *argv[]) { FILE *infile; char word[1000]; long seed; int i, j; if (argc != 2) { die("USAGE: utils <filename>"); } if (open_file(argv[1], "r", 1, "input", "", &infile) == 0) exit(1); while (fscanf(infile, "%s", word) == 1) printf("%s ", word); fclose(infile); /* Test the random number generator. */ seed = time(0); my_srand(seed); printf("\nSome random numbers (seed=%ld): \n", seed); for (i = 0; i < 10; i++) { for (j = 0; j < 10; j++) { printf("%6.4f ", my_drand()); } printf("\n"); } return(0); }
/*********************************************************************** * Fill an array with random values between 0 and a given maximum. * * Assumes that the random number generator is initialized. ***********************************************************************/ void randomize_array (ATYPE magnitude, ARRAY_T* array) { int num_items; int i_item; check_null_array(array); num_items = get_array_length(array); for (i_item = 0; i_item < num_items; i_item++) { set_array_item(i_item, my_drand() * magnitude, array); } }
/*********************************************************************** * Add random noise to an array. ***********************************************************************/ void add_noise (ATYPE magnitude, /* Magnitude of the noise. */ ARRAY_T* array) { int i_item; int num_items; ATYPE noise; check_null_array(array); num_items = get_array_length(array); for (i_item = 0; i_item < num_items; i_item++) { noise = magnitude * (2 * my_drand() - 1); incr_array_item(i_item, noise, array); } }
void* Thread_work(void* rank) { long my_rank = (long) rank; int i, val; double which_op; unsigned seed = my_rank + 1; int my_member=0, my_insert=0, my_delete=0; int ops_per_thread = total_ops/thread_count; for (i = 0; i < ops_per_thread; i++) { which_op = my_drand(&seed); val = my_rand(&seed) % MAX_KEY; if (which_op < porcentaje_busqueda) { # ifdef DEBUG printf("Hilo %ld > Buscando %d\n", my_rank, val); # endif Member(val); my_member++; } else if (which_op < porcentaje_busqueda + porcentaje_insercion) { # ifdef DEBUG printf("Hilo %ld > Insertando %d\n", my_rank, val); # endif Insert(val); my_insert++; } else { # ifdef DEBUG printf("Hilo %ld > Borrando %d\n", my_rank, val); # endif Delete(val); my_delete++; } } pthread_mutex_lock(&count_mutex); total_miembro += my_member; total_insertar += my_insert; total_borrado += my_delete; pthread_mutex_unlock(&count_mutex); return NULL; }
int main(void) { int n, i; unsigned seed = 1, x; double y; printf("Cuantos numeros aleatorios?\n"); scanf("%d", &n); x = my_rand(&seed); for (i = 0; i < n; i++) { x = my_rand(&x); printf("%u\n", x); } for (i = 0; i < n; i++) { y = my_drand(&x); printf("%e\n", y); } return 0; }
int main(void) { int n, i; unsigned seed = 1, x; double y; printf("How many random numbers?\n"); scanf("%d", &n); x = my_rand(&seed); for (i = 0; i < n; i++) { x = my_rand(&x); printf("%u\n", x); } for (i = 0; i < n; i++) { y = my_drand(&x); printf("%e\n", y); } return 0; }
/***************************************************************************** * Shuffle an array of integers using Knuth's algorithm. *****************************************************************************/ static void shuffle (int num_items, int* data) { int i_item; int i_rand; int temp_swap; // Shuffle the array. for (i_item = 0; i_item < num_items; i_item++) { // Select a random position to the right of the current position. i_rand = (int)(my_drand() * (double)(num_items - i_item)) + i_item; // Swap 'em. temp_swap = data[i_item]; data[i_item] = data[i_rand]; data[i_rand] = temp_swap; } }
/*********************************************************************** * Create a bootstrapped copy of the given array. * * Allocates the bootstrap array; must be freed by caller. * Assumes that the random number generator is initialized. ***********************************************************************/ ARRAY_T* bootstrap_array (ARRAY_T* source_array, int num_items) { ARRAY_T* return_array; check_null_array(source_array); // Allocate the bootstrap array. return_array = allocate_array(num_items); // Fill up the bootstrap array. int i_item; int num_inputs = get_array_length(source_array); for (i_item = 0; i_item < num_items; i_item++) { int random_index = (int)(my_drand() * (double)(num_inputs)); ATYPE random_item = get_array_item(random_index, source_array); set_array_item(i_item, random_item, return_array); } return(return_array); }
/*-----------------------------------------------------------------*/ void* Thread_work(void* rank) { long my_rank = (long) rank; int i, val; double which_op; unsigned seed = my_rank + 1; int my_member=0, my_insert=0, my_delete=0; int ops_per_thread = total_ops/thread_count; for (i = 0; i < ops_per_thread; i++) { which_op = my_drand(&seed); val = my_rand(&seed) % MAX_KEY; if (which_op < search_percent) { pthread_mutex_lock(&mutex); Member(val); pthread_mutex_unlock(&mutex); my_member++; } else if (which_op < search_percent + insert_percent) { pthread_mutex_lock(&mutex); Insert(val); pthread_mutex_unlock(&mutex); my_insert++; } else { /* delete */ pthread_mutex_lock(&mutex); Delete(val); pthread_mutex_unlock(&mutex); my_delete++; } } /* for */ pthread_mutex_lock(&count_mutex); member_total += my_member; insert_total += my_insert; delete_total += my_delete; pthread_mutex_unlock(&count_mutex); return NULL; } /* Thread_work */