/* allocate_rng: Allocate new random number generator from distribution
* dist to the heap.
*
* Possible dist value are:
* RNG_UNIFORM for uniform distribution
* RNG_NORMAL or RNG_GAUSSIAN for normal(gaussian) distribution
*
* It returns NULL if the malloc(3) fails and set the errno to ENOMEM.
* It returns pointer to new allocated rng_t if success. */
rng_t *allocate_rng(rng_dist_t dist)
{
rng_t *rng = malloc(sizeof *rng);
if(rng == NULL) {
errno = ENOMEM;
return NULL;
}
/* allocate pcg random number generator to the heap */
pcg32_random_t *pcg_rng = malloc(sizeof *pcg_rng);
if(pcg_rng == NULL) {
errno = ENOMEM;
return NULL;
}
/* initialize the pcg random number generator */
uint64_t initial_state = time(NULL);
intptr_t seed_value = (intptr_t)&rng;
pcg32_srandom_r(pcg_rng, initial_state, seed_value);
rng->pcg_rng = pcg_rng;
rng->pcg_initial_state = initial_state;
rng->pcg_seed_value = seed_value;
rng->distribution = dist;
return rng;
}
/*
* Seeds each rank based on the rank number and time
*/
static pcg32_random_t seed_my_rank(void)
{
const unsigned int my_rank = shmem_my_pe();
pcg32_random_t rng;
pcg32_srandom_r(&rng, (uint64_t) my_rank, (uint64_t) my_rank );
return rng;
}
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);
}
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));
}
void pcg32_srandom(uint64_t seed, uint64_t seq)
{
pcg32_srandom_r(&pcg32_global, seed, seq);
}
/** 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;
}
void kmeans(double *X, int N, int p, int metric, int *clusterids, int K, int init, double tol, int nruns) {
/*
kmeans algorithm, currently featuring:
+choice of distance metric (careful when not using euclidean!)
+initialization with random centers (init = 0) or kmeans++ (init = 1)
+returns best clustering result from nruns tries
+printf for errors instead of error code return.
function returns void but stores the best cluster assignments in clusterids
*/
double centerchg,odist,ndist,ssqd;
/* number of exemplars of each class */
double *nSamples = malloc(K*sizeof(double));
/* indices of starting centers (rows of X) */
int *centerloc = malloc(K*sizeof(int));
/* cluster centers */
double *oldCenters = malloc(K*p*sizeof(double));
double *newCenters = malloc(K*p*sizeof(double));
/* temporary labels */
int *labels = malloc(N*sizeof(int));
// RNG stuff
pcg32_random_t rng;
pcg32_srandom_r(&rng, time(NULL), (intptr_t)&rng);
double minssqd = INFINITY;
// distance selection
double (*metricptr)(double *,double *,int);
if (metric == 0) {
// euclidean distance
metricptr = &euclidean;
} else if (metric == 1) {
// cosine distance
metricptr = &cosine;
} else if (metric == 2) {
// correlation distance
metricptr = &correlation;
} else {
// default to manhattan
metricptr = &manhattan;
}
for (int irun = 0; irun < nruns; irun++) {
centerchg = 1.0+tol;
/* initialize cluster centers */
if (init == 0) {
/* random centers */
choice_floyd(&rng,centerloc,K,N);
} else if (init == 1){
/* kmeans++ */
/* holds pdf and cdf for point selection */
double *pdf = malloc(N*sizeof(double));
double *cdf = malloc(N*sizeof(double));
/* first center is chosen uniformly from the data (just ignore all
elements but centerloc[0] when we proceed) */
choice_floyd(&rng,centerloc,K,N);
/* now choose remaining centers */
for (int k = 1; k < K; k++){
/* compute center distances */
double sumDxsq = 0.0;
for (int d = 0; d < N; d ++) {
/* distance will be the minimum distance from the point to
the closest center yet found */
double mindist = INFINITY;
for (int j = 0; j < k; j++){
mindist = fmin(mindist,metricptr(&X[d*p],&X[centerloc[j]*p],p));
}
pdf[d] = mindist*mindist;
sumDxsq += pdf[d];
}
/* compute cdf */
cdf[0] = pdf[0]/sumDxsq;
for (int d = 1; d < N; d++) {
cdf[d] = pdf[d]/sumDxsq + cdf[d-1];
}
/* now we have the probability vector; find the new center */
centerloc[k] = rand_cdf_index(&rng,cdf,N);
}
/* have the centers, free memory */
free(pdf);
free(cdf);
} else {
printf("ERROR! Unknown initialization method.");
}
for (int i = 0; i < K; i++) {
for (int j = 0; j < p; j++) {
oldCenters[i*p + j] = X[centerloc[i]*p + j];
}
}
/* run until convergence */
for (int r = 0; r < 1000; r++) {
/* find closest center */
for (int i = 0; i < N; i++) {
odist = metricptr(&X[i*p],&oldCenters[0],p);
labels[i] = 0;
for (int k = 0; k < K; k++) {
ndist = metricptr(&X[i*p],&oldCenters[k*p],p);
if (ndist < odist) {
odist = ndist;
labels[i] = k;
}
}
}
/* recompute new centers */
for (int k = 0; k < K; k++) {
nSamples[k] = 0.0;
for(int j = 0; j < p; j++) {
newCenters[k*p + j] = 0.0;
}
}
for (int i = 0; i < N; i++) {
nSamples[labels[i]] += 1.0;
}
for (int j = 0; j < N ; j++) {
for (int l = 0; l < p; l++) {
newCenters[labels[j]*p + l] += X[j*p + l]/nSamples[labels[j]];
}
}
/* check to see if centers have changed enough to continue */
centerchg = 0.0;
for (int k = 0; k < K; k++) {
centerchg += metricptr(&newCenters[k*p],&oldCenters[k*p],p);
}
if (centerchg < tol) {
break;
}
/* copy newCenters into oldCenters */
for (int i = 0; i < K; i++) {
for (int j = 0; j < p; j++) {
oldCenters[i*p + j] = newCenters[i*p + j];
}
}
}
/* compute ssd and copy into clusterids in case this is the best run */
ssqd = 0.0;
for (int i = 0; i < N; i++) {
ssqd += metricptr(&X[i*p],&newCenters[labels[i]*p],p);
}
if (ssqd < minssqd) {
minssqd = ssqd;
memcpy(clusterids,labels,N*sizeof(*clusterids));
}
}
/* free memory */
free(nSamples);
free(labels);
free(centerloc);
free(oldCenters);
free(newCenters);
return;
}
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;
}
void set_seed(uint64_t initstate, uint64_t initseq){
pcg32_srandom_r(&rng, initstate, initseq);
}
