void pcg32_srandom_r(pcg32_random_t* rng, uint64_t initial_state, uint64_t initseq) { rng->state = 0U; rng->inc = (initseq << 1u) | 1u; pcg32_random_r(rng); rng->state += initial_state; pcg32_random_r(rng); }
uint32_t pcg32_boundedrand_r(pcg32_random_t* rng, uint32_t bound) { // To avoid bias, we need to make the range of the RNG a multiple of // bound, which we do by dropping output less than a threshold. // A naive scheme to calculate the threshold would be to do // // uint32_t threshold = 0x100000000ull % bound; // // but 64-bit div/mod is slower than 32-bit div/mod (especially on // 32-bit platforms). In essence, we do // // uint32_t threshold = (0x100000000ull-bound) % bound; // // because this version will calculate the same modulus, but the LHS // value is less than 2^32. uint32_t threshold = -bound % bound; // Uniformity guarantees that this loop will terminate. In practice, it // should usually terminate quickly; on average (assuming all bounds are // equally likely), 82.25% of the time, we can expect it to require just // one iteration. In the worst case, someone passes a bound of 2^31 + 1 // (i.e., 2147483649), which invalidates almost 50% of the range. In // practice, bounds are typically small and only a tiny amount of the range // is eliminated. for (;;) { uint32_t r = pcg32_random_r(rng); if (r >= threshold) return r % bound; } }
void mutate(gsl_matrix *chromosome, gsl_matrix *bounds, pcg32_random_t *rng) { uint32_t rows = chromosome->size1, cols = chromosome->size2, row, col; double r, min, max; // Select a random row and column row = (uint32_t)pcg32_boundedrand_r(rng, rows); col = (uint32_t)pcg32_boundedrand_r(rng, cols); // Set to a random value within the bounds min = gsl_matrix_get(bounds, col, 0); max = gsl_matrix_get(bounds, col, 1); r = (ldexp(pcg32_random_r(rng), -32) * (max - min)) + min; gsl_matrix_set(chromosome, row, col, r); if (DEBUG == DEBUG_MUTATE) { printf(YELLOW "MUTATED CHROMSOME\n" RESET); printf(YELLOW "ROW: %d, COL: %d, VAL: %10.6f\n" RESET, row, col, r); for (uint32_t i = 0; i < rows; ++i) { for (uint32_t j = 0; j < cols; ++j) { printf(YELLOW "%10.6f " RESET, gsl_matrix_get(chromosome, i, j)); } printf("\n"); } } }
void dostep(world *w){ int nextbind = pcg32_boundedrand_r(&rng, w->nbonds); //ran_int(0, w->nbonds); int nextbond = w->bonds[nextbind]; double test = ldexp(pcg32_random_r(&rng), -32); int ind0, ind1; bond2inds(w->N, nextbond, &ind0, &ind1); int ind = 0; int tx, ty; if (w->grid[ind0] == w->grid[ind1]){ remove_bond(w, nextbond); return; } if (test < 1.0/(1+w->alpha)){ ind = ind0 * (w->grid[ind0] == SS) + ind1 * (w->grid[ind1] == SS); ind2xy(w->N, ind, &tx, &ty); add_zombie(w, tx, ty); } else { ind = ind0 * (w->grid[ind0] == SZ) + ind1 * (w->grid[ind1] == SZ); ind2xy(w->N, ind, &tx, &ty); kill_site(w, tx, ty); } }
int rand_cdf_index(pcg32_random_t *rng, double *cdf, int N) { /* uniform random number between 0 and 1 */ double r = ldexp(pcg32_random_r(rng), -32); for (int i = 0; i < N; i++){ if (r < cdf[i]) { return i; } } return 0; }
int main() { Node* nodes = calloc(N, sizeof(Node)); struct Heap heap; heap_init(&heap, nodes, N, D); pcg32_random_t rng1; pcg32_srandom_r(&rng1, time(NULL), (intptr_t)&rng1); for (int i = 0; i < N; i++) { Node* newnode = heap.nodes + i; newnode->id = i + 1; newnode->min_edge = 100 * (float) pcg32_random_r(&rng1) / UINT32_MAX; } heap_number(&heap); printf("unordered: \n"); print_heap(&heap); min_heapify(&heap); printf("ordered: \n"); print_heap(&heap); printf("min: %f\n\n", heap_find_min(&heap).min_edge); heap_deletemin(&heap); printf("deletemin: \n"); print_heap(&heap); Node n = {.min_edge = 2.0, .id = heap.n + 1}; heap_insert(&heap, n); printf("\ninsert: \n"); print_heap(&heap); /*for (int i = 0; i < N; i++) { printf("min: %f\n\n", heap_find_min(&heap).min_edge); heap_deletemin(&heap); printHeap(&heap); } */ free_heap(&heap); }
int get_random_value_rng(rng_t *rng, double *output) { if(rng == NULL) { errno = EINVAL; return -1; } if(rng->distribution == RNG_UNIFORM) { uint32_t random_number = pcg32_random_r(rng->pcg_rng); double value = ldexp(random_number, -32); *output = value; return 0; } return -1; }
void presentencrypt(char *str, uint8_t *retstr) { pcg32_random_t rng; pcg32_srandom_r(&rng, time(NULL) ^ (intptr_t)&printf, (intptr_t)&rounds); uint32_t rang = pcg32_random_r(&rng); memcpy(iv,&rang,sizeof(iv)); uint8_t newMessage[200]; //pad the message string and turn into bytearray padStr(str,newMessage); cbc_encrypt((uint8_t*)theKey,iv,newMessage,lenmsg); memcpy(retstr,newMessage,sizeof(newMessage)); printf("sizeof(newMessage) %d\n", sizeof(newMessage)); }
/* rng_get_random_value: Get the next random number from random number * generator rng and write the result to the output. * * It returns non-zero value if output is NULL * It returns zero if the operation success, the random number will be * written into output */ int rng_get_random_value(rng_t rng, double *output) { if(output == NULL) { errno = EINVAL; return -1; } if(rng.distribution == RNG_UNIFORM) { uint32_t random_number = pcg32_random_r(rng.pcg_rng); double value = ldexp(random_number, -32); *output = value; return 0; } /* TODO(pyk): implement NORMAL or GAUSSIAN distribution */ return -1; }
int select_parent(int size, double probability[size], pcg32_random_t *rng) { int idx = 0; double r = pcg32_random_r(rng) / (double)UINT32_MAX; for (int i = 0; i < size; ++i) { if (i == 0) { if (r < probability[i]) { idx = i; break; } } else if (r >= probability[i-1] && r < probability[i]) { idx = i; break; } } return idx; }
uint32_t pcg32_random() { return pcg32_random_r(&pcg32_global); }
uint32_t Math::rand() { return pcg32_random_r(&default_pcg); }
// TODO: we should eventually expose pcg.inc too uint32_t Math::rand_from_seed(uint64_t *seed) { pcg32_random_t pcg = { *seed, PCG_DEFAULT_INC_64 }; uint32_t r = pcg32_random_r(&pcg); *seed = pcg.state; return r; }
/** Initialize the SSL context. * \return pointer to SSL context object. */ SSL_CTX * ssl_init(char *private_key_file, char *ca_file, char *ca_dir, int req_client_cert) { const SSL_METHOD *meth; /* If this const gives you a warning, you're using an old version of OpenSSL. Walker, this means you! */ /* uint8_t context[128]; */ unsigned int reps = 1; pcg32_random_t rand_state; uint64_t seeds[2]; bool seeded = false; if (!bio_err) { if (!SSL_library_init()) return NULL; SSL_load_error_strings(); /* Error write context */ bio_err = BIO_new_fp(stderr, BIO_NOCLOSE); } lock_file(stderr); fputs("Seeding OpenSSL random number pool.\n", stderr); unlock_file(stderr); while (!RAND_status()) { /* At this point, a system with /dev/urandom or a EGD file in the usual places will have enough entropy. Otherwise, be lazy and use random numbers until it's satisfied. */ uint32_t gibberish[8]; int n; if (!seeded) { generate_seed(seeds); pcg32_srandom_r(&rand_state, seeds[0], seeds[1]); seeded = 1; } for (n = 0; n < 8; n++) gibberish[n] = pcg32_random_r(&rand_state); RAND_seed(gibberish, sizeof gibberish); reps += 1; } lock_file(stderr); fprintf(stderr, "Seeded after %u %s.\n", reps, reps > 1 ? "cycles" : "cycle"); unlock_file(stderr); /* Set up SIGPIPE handler here? */ /* Create context */ #if OPENSSL_VERSION_NUMBER >= 0x10100000L meth = TLS_server_method(); #else meth = SSLv23_server_method(); #endif ctx = SSL_CTX_new(meth); SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3); /* Load keys/certs */ if (private_key_file && *private_key_file) { if (!SSL_CTX_use_certificate_chain_file(ctx, private_key_file)) { ssl_errordump("Unable to load server certificate - only anonymous " "ciphers supported."); } if (!SSL_CTX_use_PrivateKey_file(ctx, private_key_file, SSL_FILETYPE_PEM)) { ssl_errordump( "Unable to load private key - only anonymous ciphers supported."); } } /* Load trusted CAs */ if ((ca_file && *ca_file) || (ca_dir && *ca_dir)) { if (!SSL_CTX_load_verify_locations(ctx, (ca_file && *ca_file) ? ca_file : NULL, (ca_dir && *ca_dir) ? ca_dir : NULL)) { ssl_errordump("Unable to load CA certificates"); } { STACK_OF(X509_NAME) *certs = NULL; if (ca_file && *ca_file) certs = SSL_load_client_CA_file(ca_file); if (certs) SSL_CTX_set_client_CA_list(ctx, certs); if (req_client_cert) SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, client_verify_callback); else SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, client_verify_callback); #if (OPENSSL_VERSION_NUMBER < 0x0090600fL) SSL_CTX_set_verify_depth(ctx, 1); #endif } } SSL_CTX_set_options(ctx, SSL_OP_SINGLE_DH_USE | SSL_OP_ALL); SSL_CTX_set_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE | SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER); /* Set up DH key */ { DH *dh; dh = get_dh2048(); SSL_CTX_set_tmp_dh(ctx, dh); DH_free(dh); } #ifdef NID_X9_62_prime256v1 /* Set up ECDH key */ { EC_KEY *ecdh = NULL; ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); SSL_CTX_set_tmp_ecdh(ctx, ecdh); EC_KEY_free(ecdh); } #endif /* Set the cipher list to the usual default list, except that * we'll allow anonymous diffie-hellman, too. */ SSL_CTX_set_cipher_list(ctx, "ALL:ECDH:ADH:!LOW:!MEDIUM:@STRENGTH"); /* Set up session cache if we can */ /* strncpy((char *) context, MUDNAME, 128); SSL_CTX_set_session_id_context(ctx, context, strlen(context)); */ return ctx; }
int main(int argc, char** argv) { // Read command-line options int rounds = 5; bool nondeterministic_seed = false; int round, i; ++argv; --argc; if (argc > 0 && strcmp(argv[0], "-r") == 0) { nondeterministic_seed = true; ++argv; --argc; } if (argc > 0) { rounds = atoi(argv[0]); } // In this version of the code, we'll use a local rng, rather than the // global one. pcg32_random_t rng; // You should *always* seed the RNG. The usual time to do it is the // point in time when you create RNG (typically at the beginning of the // program). // // pcg32_srandom_r takes two 64-bit constants (the initial state, and the // rng sequence selector; rngs with different sequence selectors will // *never* have random sequences that coincide, at all) - the code below // shows three possible ways to do so. if (nondeterministic_seed) { // Seed with external entropy -- the time and some program addresses // (which will actually be somewhat random on most modern systems). // A better solution, entropy_getbytes, using /dev/random, is provided // in the full library. pcg32_srandom_r(&rng, time(NULL) ^ (intptr_t)&printf, (intptr_t)&rounds); } else { // Seed with a fixed constant pcg32_srandom_r(&rng, 42u, 54u); } printf("pcg32_random_r:\n" " - result: 32-bit unsigned int (uint32_t)\n" " - period: 2^64 (* 2^63 streams)\n" " - state type: pcg32_random_t (%zu bytes)\n" " - output func: XSH-RR\n" "\n", sizeof(pcg32_random_t)); for (round = 1; round <= rounds; ++round) { printf("Round %d:\n", round); /* Make some 32-bit numbers */ printf(" 32bit:"); for (i = 0; i < 6; ++i) printf(" 0x%08x", pcg32_random_r(&rng)); printf("\n"); /* Toss some coins */ printf(" Coins: "); for (i = 0; i < 65; ++i) printf("%c", pcg32_boundedrand_r(&rng, 2) ? 'H' : 'T'); printf("\n"); /* Roll some dice */ printf(" Rolls:"); for (i = 0; i < 33; ++i) { printf(" %d", (int)pcg32_boundedrand_r(&rng, 6) + 1); } printf("\n"); /* Deal some cards */ enum { SUITS = 4, NUMBERS = 13, CARDS = 52 }; char cards[CARDS]; for (i = 0; i < CARDS; ++i) cards[i] = i; for (i = CARDS; i > 1; --i) { int chosen = pcg32_boundedrand_r(&rng, i); char card = cards[chosen]; cards[chosen] = cards[i - 1]; cards[i - 1] = card; } printf(" Cards:"); static const char number[] = {'A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K'}; static const char suit[] = {'h', 'c', 'd', 's'}; for (i = 0; i < CARDS; ++i) { printf(" %c%c", number[cards[i] / SUITS], suit[cards[i] % SUITS]); if ((i + 1) % 22 == 0) printf("\n\t"); } printf("\n"); printf("\n"); } return 0; }
/** * The E-means algorithm, uses a genetic algorithm to optimize the parameters * for the K-means implemetation of clustering based Lloyds clustering algorithm. * * @return Status code, 0 for SUCCESS, 1 for ERROR */ int emeans(void) { gsl_matrix *data = NULL, *bounds = NULL, *parent1 = NULL, *parent2 = NULL, **population = NULL, **new_population = NULL, ***clusters = NULL; int status = SUCCESS; double fitness[size], probability[size]; // Initialize the PRNG pcg32_random_t rng; int rounds = 5; pcg32_srandom_r(&rng, time(NULL) ^ (intptr_t)&printf, (intptr_t)&rounds); // Allocate memory and load the data data = gsl_matrix_alloc(data_rows, data_cols); bounds = gsl_matrix_alloc(data_cols, 2); parent1 = gsl_matrix_alloc(n_clusters, data_cols); parent2 = gsl_matrix_alloc(n_clusters, data_cols); population = (gsl_matrix **)calloc(size, sizeof(gsl_matrix **)); new_population = (gsl_matrix **)calloc(size, sizeof(gsl_matrix **)); clusters = (gsl_matrix ***)calloc(size, sizeof(gsl_matrix ***)); for (int i = 0; i < (int)size; ++i) { clusters[i] = (gsl_matrix **)calloc(n_clusters, sizeof(gsl_matrix **)); population[i] = gsl_matrix_alloc(n_clusters, data_cols); new_population[i] = gsl_matrix_alloc(n_clusters, data_cols); } if ((status = load_data(data_file, data)) != SUCCESS) { fprintf(stderr, RED "Unable to load data!\n" RESET); status = ERROR; goto free; } // Calculate the bounds of the data calc_bounds(data, bounds); // Generate the initial population printf(CYAN "Generating initial population...\n" RESET); for (int i = 0; i < (int)size; ++i) { random_centroids(population[i], bounds, &rng); } // Perform the Genetic Algorithm for (int iter = 0; iter < max_iter; ++iter) { // Compute the fitness of each chromosome for (int i = 0; i < (int)size; ++i) { lloyd_defined(trials, population[i], data, n_clusters, clusters[i]); fitness[i] = dunn_index(population[i], n_clusters, clusters[i]); if (VERBOSE == 1) printf(CYAN "chromsome[%d], fitness: %10.6f\n" RESET, i, fitness[i]); } // Generate the probabilities for roulette wheel selection gen_probability(size, fitness, probability); // Save the results if there is a new best solution save_results(fitness_file, centroids_file, cluster_file, size, fitness, population, n_clusters, clusters); // Perform roulette wheel selection and GA operators if (VERBOSE == 1) printf(CYAN "Executing roulette wheel selection...\n" RESET); // Select parents from the population and perform genetic operators for (int i = 0; i < size; i += 2) { // Select parents for (int j = 0, idx = 0; j < 2; ++j) { idx = select_parent(size, probability, &rng); if (VERBOSE == 1) printf(CYAN "Parent %d selected as chromsome %d from population\n" RESET, j, idx); if (j == 0) gsl_matrix_memcpy(parent1, population[idx]); else gsl_matrix_memcpy(parent2, population[idx]); } // Perform crossover and mutation with specified probabilities if (VERBOSE == 1) printf(CYAN "Performing crossover...\n" RESET); if (pcg32_random_r(&rng) / (double)UINT32_MAX <= c_rate) { crossover(parent1, parent2, &rng); } if (VERBOSE == 1) printf(CYAN "Performing background mutation...\n" RESET); for (int j = 0; j < 2; ++j) { if (pcg32_random_r(&rng) / (double)UINT32_MAX <= m_rate) { if (j == 0) mutate(parent1, bounds, &rng); else mutate(parent2, bounds, &rng); } } // Copy each parent to the new population if (VERBOSE == 1) printf(CYAN "Copying parents to new population...\n" RESET); gsl_matrix_memcpy(new_population[i], parent1); gsl_matrix_memcpy(new_population[i+1], parent2); } // Copy the new population to the next population if (VERBOSE == 1) printf(CYAN "Copying current population as new population\n" RESET); for (int i = 0; i < size; ++i) { gsl_matrix_memcpy(population[i], new_population[i]); } // Check if stop signal, terminate if present if (access("./stop", F_OK) != -1) { printf(YELLOW "Stop signal received, shutting down!\n" RESET); remove("./stop"); break; } } printf(GREEN "Finished executing E-means, shutting down!\n" RESET); free: for (int i = 0; i < (int)size; ++i) { for (int j = 0; j < n_clusters; ++j) { gsl_matrix_free(clusters[i][j]); } free(clusters[i]); } free(clusters); for (int i = 0; i < (int)size; ++i) { gsl_matrix_free(population[i]); gsl_matrix_free(new_population[i]); } free(population); free(new_population); gsl_matrix_free(data); gsl_matrix_free(bounds); return status; }