//retrieve the kolmogorov skewness, kolmogorov constant
void retr_skewness_structure_functions(
int *n,
double *v,
int *retr_n,
int *periodic,
double *retr_skewness,
double *retr_constant
)
{
int i1, i2, nok;
int ni, ni_2, ni_2m;
double *lst_skewness = malloc(*retr_n * sizeof(double));
double *lst_const = malloc(*retr_n * sizeof(double));
int j;
double avg;
for (i1 = 0; i1 < *n; i1 = i1 + *retr_n ) {
i2 = i1 + (*retr_n -1);
if (i2 >= *n) {
i2 = *n -1;
i1 = fmax(0, i2 - (*retr_n - 1));
}
ni = i2 + 1 - i1;
ni_2 = ni/2.;
ni_2m = ni_2 - 1;
//Kolmogorov skewness:
//6.89: S = DLLL(t) / (DLL(t) ** 3/2)
//Kolmogorov constant C:
//6.90: C = (-4 / (5 S)) ** (2/3)
kolmogorov_skewness(&ni, v + i1, lst_skewness, periodic);
for (j = 1; j < ni_2; j++ ) {
lst_const[j] = pow(fabs(-4. / (5. * lst_skewness[j])) , 2. / 3.);
}
calc_avg(&ni_2m, v + 1, &avg, &nok);
for (j = i1; j <= i2; j++ ) {
retr_skewness[j] = avg;
}
calc_avg(&ni_2m, lst_const + 1, &avg, &nok);
for (j = i1; j <= i2; j++ ) {
retr_constant[j] = avg;
}
}
free(lst_skewness);
free(lst_const);
}
float calc_rating(KINGDOM_DATA * kingdom)
{
if(!kingdom)
return 0;
if(kingdom->id == 0)
return -1;
return (calc_kd(kingdom) * calc_avg(kingdom));
}
int main(void)
{
double stuff[ROWS][COLS];
int row;
for(row = 0; row < ROWS; row++)
{
printf("Enter %d numbers for row %d\n", COLS, row + 1);
store(*(stuff + row), COLS);
}
printf("array contents:\n");
show_arr(stuff, ROWS);
for(row = 0; row < ROWS; row++)
printf("average value of row %d = %g\n", row + 1, calc_avg(*(stuff + row), COLS));
printf("average value of all rows = %g\n", calc_all_avg(stuff, ROWS));
printf("largest value = %g\n", seek_max(stuff, ROWS));
printf("Bye!\n");
return 0;
}
static void test_ciphersuite_kx(const char *cipher_prio, unsigned pk)
{
/* Server stuff. */
gnutls_anon_server_credentials_t s_anoncred;
gnutls_session_t server;
int sret, cret;
const char *str;
char *suite = NULL;
/* Client stuff. */
gnutls_anon_client_credentials_t c_anoncred;
gnutls_certificate_credentials_t c_certcred, s_certcred;
gnutls_session_t client;
/* Need to enable anonymous KX specifically. */
int ret;
struct benchmark_st st;
struct timespec tr_start, tr_stop;
double avg, sstddev;
gnutls_priority_t priority_cache;
total_diffs_size = 0;
/* Init server */
gnutls_certificate_allocate_credentials(&s_certcred);
gnutls_anon_allocate_server_credentials(&s_anoncred);
ret = 0;
if (pk == GNUTLS_PK_RSA_PSS)
ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_rsa_pss_cert,
&server_key,
GNUTLS_X509_FMT_PEM);
else if (pk == GNUTLS_PK_RSA)
ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_cert,
&server_key,
GNUTLS_X509_FMT_PEM);
if (ret < 0) {
fprintf(stderr, "Error in %d: %s\n", __LINE__,
gnutls_strerror(ret));
exit(1);
}
ret = 0;
if (pk == GNUTLS_PK_ECDSA)
ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_ecc_cert,
&server_ecc_key,
GNUTLS_X509_FMT_PEM);
else if (pk == GNUTLS_PK_EDDSA_ED25519)
ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_ed25519_cert,
&server_ed25519_key,
GNUTLS_X509_FMT_PEM);
if (ret < 0) {
fprintf(stderr, "Error in %d: %s\n", __LINE__,
gnutls_strerror(ret));
exit(1);
}
/* Init client */
gnutls_anon_allocate_client_credentials(&c_anoncred);
gnutls_certificate_allocate_credentials(&c_certcred);
start_benchmark(&st);
ret = gnutls_priority_init(&priority_cache, cipher_prio, &str);
if (ret < 0) {
fprintf(stderr, "Error in %s\n", str);
exit(1);
}
do {
gnutls_init(&server, GNUTLS_SERVER);
ret =
gnutls_priority_set(server, priority_cache);
if (ret < 0) {
fprintf(stderr, "Error in setting priority: %s\n", gnutls_strerror(ret));
exit(1);
}
gnutls_credentials_set(server, GNUTLS_CRD_ANON,
s_anoncred);
gnutls_credentials_set(server, GNUTLS_CRD_CERTIFICATE,
s_certcred);
gnutls_transport_set_push_function(server, server_push);
gnutls_transport_set_pull_function(server, server_pull);
gnutls_transport_set_ptr(server,
(gnutls_transport_ptr_t) server);
reset_buffers();
gnutls_init(&client, GNUTLS_CLIENT);
ret =
gnutls_priority_set(client, priority_cache);
if (ret < 0) {
fprintf(stderr, "Error in setting priority: %s\n", gnutls_strerror(ret));
exit(1);
}
gnutls_credentials_set(client, GNUTLS_CRD_ANON,
c_anoncred);
gnutls_credentials_set(client, GNUTLS_CRD_CERTIFICATE,
c_certcred);
gnutls_transport_set_push_function(client, client_push);
gnutls_transport_set_pull_function(client, client_pull);
gnutls_transport_set_ptr(client,
(gnutls_transport_ptr_t) client);
gettime(&tr_start);
HANDSHAKE(client, server);
gettime(&tr_stop);
if (suite == NULL)
suite =
gnutls_session_get_desc(server);
gnutls_deinit(client);
gnutls_deinit(server);
total_diffs[total_diffs_size++] = timespec_sub_ms(&tr_stop, &tr_start);
if (total_diffs_size > sizeof(total_diffs)/sizeof(total_diffs[0]))
abort();
st.size += 1;
}
while (benchmark_must_finish == 0);
fprintf(stdout, "%38s ", suite);
gnutls_free(suite);
stop_benchmark(&st, "transactions", 1);
gnutls_priority_deinit(priority_cache);
avg = calc_avg(total_diffs, total_diffs_size);
sstddev = calc_sstdev(total_diffs, total_diffs_size, avg);
printf("%32s %.2f ms, sample variance: %.2f)\n",
"(avg. handshake time:", avg, sstddev);
gnutls_anon_free_client_credentials(c_anoncred);
gnutls_anon_free_server_credentials(s_anoncred);
}
//retrieve the fraction S, kolmogorov constant
void retr_factor_wind_components(
int *n,
double *u,
double *v,
double *w,
int *retr_n,
int *periodic,
double *retr_frachor, //retrieved factor between components
double *retr_fracver //retrieved factor between components
)
{
int order = 2;
int i1, i2, nok;
int ni, ni_2, ni_2m;
double *u_dir = malloc(*n * sizeof(double));
double *u_lon = malloc(*n * sizeof(double));
double *u_tra1 = malloc(*n * sizeof(double));
double *u_tra2 = malloc(*n * sizeof(double));
double *dll_lon = malloc(*n * sizeof(double));
double *dll_tra1 = malloc(*n * sizeof(double));
double *dll_tra2 = malloc(*n * sizeof(double));
double *lst_frac = malloc(*n * sizeof(double));
int j;
double avg;
//Calculate longitudinal and transverse components of the wind.
for (j = 0; j <= *n; j++ ) {
//wind vector direction w.r.t. east (u-direction)
u_dir[j] = atan2(v[j], u[j]);
//now calculate longitudinal component
u_lon[j] = (cos(u_dir[j]) * u[j]) + (sin(u_dir[j]) * v[j]);
//and transverse componenents
u_tra1[j] = (sin(u_dir[j]) * u[j]) + (sin(u_dir[j]) * v[j]);
u_tra2[j] = w[j];
}
for (i1 = 0; i1 < *n; i1 = i1 + *retr_n ) {
i2 = i1 + (*retr_n -1);
if (i2 >= *n) {
i2 = *n -1;
i1 = fmax(0, i2 - (*retr_n - 1));
}
ni = i2 + 1 - i1;
ni_2 = ni/2.;
ni_2m = ni_2 - 1;
//calculate second order structure function.
structure_function(&ni, u_lon + i1, dll_lon, &order, periodic);
structure_function(&ni, u_tra1 + i1, dll_tra1, &order, periodic);
structure_function(&ni, u_tra2 + i1, dll_tra2, &order, periodic);
//using horizontal components
for (j = 0; j < ni_2; j++ ) {
lst_frac[j] = dll_lon[j] / dll_tra1[j]; //in theory 4/3
}
calc_avg(&ni_2, lst_frac, &avg, &nok);
for (j = i1; j <= i2; j++ ) {
retr_frachor[j] = avg;
}
//using horizontal + vertical components
for (j = 0; j < ni_2; j++ ) {
lst_frac[j] = dll_lon[j] / dll_tra2[j]; //in theory 4/3
}
calc_avg(&ni_2, lst_frac, &avg, &nok);
for (j = i1; j <= i2; j++ ) {
retr_fracver[j] = avg;
}
}
free(u_dir);
free(u_lon);
free(u_tra1);
free(u_tra2);
free(dll_lon);
free(dll_tra1);
free(dll_tra2);
free(lst_frac);
}
void main (void)
{
sec_counter=0;
ADCON0 = 0x01;
ADCON1 = 0x0E;
ADCON2 = 0xFF;
T0CON = 0x80;
INTCON = 0xE0;
T1CON = 0x11;
PIR1bits.TMR1IF = 0;
PIE1bits.TMR1IE = 1;
OSCCON = 0x70;
TRISD = 0;
TRISE = 0;
LATE = 0;
LATD = 0;
BTN_T = 1;
LEDR_T = 0;
LEDY_T = 0;
LEDG_T = 0;
disp_array[0] = 0;
disp_array[1] = 1;
disp_array[2] = 2;
temp_array_pointer = 0;
FET = 0;
FET_T = 0;
state = 1;
state_count = 5;
minutes_set = 1;
beeper = 0;
err_counter = 0;
BEEPER_T = 0;
BEEPER = 0;
temper_val=0;
while (1)
{
temper = temp_read();
if ((temper>2)&(temper<200))
{
Delay10KTCYx(10);
err_counter = 0;
temp_array[temp_array_pointer] = temper;
temp_array_pointer++;
if (temp_array_pointer==TEMP_ARRAY_SIZE) temp_array_pointer = 0;
temper = calc_avg(temp_array,TEMP_ARRAY_SIZE);
if (temper<temp_set)
{
LEDR = 1;
FET = 1;
}
else
{
FET = 0;
LEDR = 0;
}
if (state==0)
{
LEDG = 1;
LEDY = 0;
disp_array[0] = temper/100;
disp_array[1] = (temper - (disp_array[0]*100))/10;
disp_array[2] = temper - (disp_array[0]*100) - (disp_array[1]*10);
state_count = 0;
if (BTN==0)
{
state = 2;
if (temper_val<(TEMPER_VAL_MAX-1))
temper_val++;
else
temper_val=0;
}
}
temp_set = temperatures[temper_val];
if (state==1)
{
LEDG = 0;
LEDY = 1;
if (state_count>0)
state_count--;
else
state = 0;
disp_array[0] = temp_set/100;
disp_array[1] = (temp_set - (disp_array[0]*100))/10;
disp_array[2] = temp_set - (disp_array[0]*100) - (disp_array[1]*10);
}
if (state==2)
{
LEDG = 0;
LEDY = 0;
disp_array[0] = temp_set/100;
disp_array[1] = (temp_set - (disp_array[0]*100))/10;
disp_array[2] = temp_set - (disp_array[0]*100) - (disp_array[1]*10);
state_count = 5;
if (BTN==1)
state = 1;
}
}
else
{
}
}
}
void Frameset::normalize_stat(struct abbrev_stat *stat, __u64 count)
{
stat->sum = (__u64)calc_avg(stat->sum, count);
stat->sos = (__u64)calc_avg(stat->sos, count);
}
void do_klist(CHAR_DATA * ch, char *argument)
{
KINGDOM_DATA *kingdom;
char buf[MAX_STRING_LENGTH];
long i = 0, iw = 0;
long highest = 0;
if(is_number(argument))
{
buf[0] = '\0';
if((kingdom = get_kingdom(atoi(argument))) == &kingdom_default)
{
send_to_char("There is no kingdom with that ID.\n\r", ch);
return;
}
kingdom = get_kingdom(atoi(argument));
sprintf(buf + strlen(buf), " Leader: %-25s Name: %s\n\r", kingdom->leader, kingdom->name);
sprintf(buf + strlen(buf), " PKS: %-25li PDS: %li\n\r", kingdom->pks, kingdom->pds);
sprintf(buf + strlen(buf), " K/D: %-25.2f\n\r", calc_kd(kingdom));
sprintf(buf + strlen(buf), " Points: %-25li Total: %li\n\r", kingdom->points, kingdom->realpoints);
sprintf(buf + strlen(buf), " Rating: %-25.2f AVG: %.2f\n\r", calc_rating(kingdom), calc_avg(kingdom));
sprintf(buf + strlen(buf), "Members:\n\r%s\n\r", kingdom->members);
sprintf(buf + strlen(buf), "Trustees:\n\r%s\n\r", kingdom->trustees);
sprintf(buf + strlen(buf), "Treaties:\n\r");
for(i = 0; i < kingdom->treaties[i]; i++)
{
sprintf(buf + strlen(buf), "%-25s %s",
get_kingdom(kingdom->treaties[i]) !=
0 ? get_kingdom(kingdom->treaties[i])->name : "Null", (i + 1) % 2 == 0 ? "\n\r" : "");
}
if((i + 1) % 2 == 0)
sprintf(buf + strlen(buf), "\n\r");
sprintf(buf + strlen(buf), "Wars:\n\r");
for(i = 0; i < kingdom->wars[i]; i++)
{
sprintf(buf + strlen(buf), "%-25s %s",
get_kingdom(kingdom->wars[i]) != 0 ? get_kingdom(kingdom->wars[i])->name : "Null",
(i + 1) % 2 == 0 ? "\n\r" : "");
}
if((i + 1) % 2 == 0)
sprintf(buf + strlen(buf), "\n\r");
sprintf(buf + strlen(buf), "\n\r\n\r");
send_to_char(buf, ch);
return;
}
buf[0] = '\0';
if(argument[0] != '\0')
{
if(!str_prefix(argument, "wars"))
{
sprintf(buf, "{RWARS{N:\n\r");
for(kingdom = kingdom_list; kingdom; kingdom = kingdom->next)
{
for(iw = 0; iw < kingdom->wars[iw]; iw++)
sprintf(buf + strlen(buf), "%s is at {RWAR{N with %s.\n\r",
kingdom->name, get_kingdom(kingdom->wars[iw])->name);
}
sprintf(buf + strlen(buf), "\n\r");
send_to_char(buf, ch);
return;
}
if(!str_prefix(argument, "treaties"))
{
long *kingdoms;
long x = 0, curr = 0;
bool already = FALSE;
bool logged = FALSE;
kingdoms = malloc(sizeof(long) * num_kingdoms());
memset(kingdoms, 0, sizeof(long) * num_kingdoms());
sprintf(buf, "{GTREATIES{N, in no particular order:\n\r");
for(kingdom = kingdom_list; kingdom; kingdom = kingdom->next, logged = FALSE)
{
for(iw = 0; iw < kingdom->treaties[i]; iw++)
{
for(x = 0; x < num_kingdoms(); x++)
{
if(kingdoms[x] == kingdom->treaties[iw])
{
already = TRUE;
break;
}
}
if(already)
{
already = FALSE;
continue;
}
if(!logged)
{
kingdoms[curr] = kingdom->id;
curr++;
logged = TRUE;
}
sprintf(buf + strlen(buf), "%s and %s have a treaty together.\n\r",
kingdom->name, get_kingdom(kingdom->treaties[iw])->name);
}
}
free(kingdoms);
sprintf(buf + strlen(buf), "\n\r");
send_to_char(buf, ch);
return;
}
}
sprintf(buf, "[ID] %-10s [Pks] [Pds] [Ast] [K/D] [Points] [AVG] [Rating] [Name]\n\r", "[Leader]");
for(kingdom = kingdom_list; kingdom; kingdom = kingdom->next)
{
if( kingdom->id > highest )
highest = kingdom->id;
}
for(i = 1, iw=0; i <= highest; i++)
{
if( (kingdom = get_kingdom(i)) == &kingdom_default )
continue;
iw++;
sprintf(buf + strlen(buf), "%s%-4li %-10s %-5li %-5li %-5li %-5.2f %-8li %-5li %-8li %s%s\n\r",
i % 2 == 0 ? "{Y" : "{R",
kingdom->id,
kingdom->leader,
kingdom->pks,
kingdom->pds,
kingdom->assists,
calc_kd(kingdom),
kingdom->points,
(long) calc_avg(kingdom), (long) calc_rating(kingdom), kingdom->name, iw % 2 == 0 ? "{Y" : "{R");
}
sprintf(buf + strlen(buf), "{N\n\r");
send_to_char(buf, ch);
send_to_char("To get more information about a kingdom, type: klist <id#>\n\r", ch);
}
static void
client (int fd, const char* prio, unsigned int text_size, struct test_st *test)
{
int ret;
char buffer[MAX_BUF + 1];
char text[text_size];
gnutls_certificate_credentials_t x509_cred;
gnutls_session_t session;
struct timespec start, stop;
static unsigned long taken = 0;
static unsigned long measurement;
const char* err;
global_init ();
setpriority(PRIO_PROCESS, getpid(), -15);
memset(text, 0, text_size);
#ifdef DEBUG
gnutls_global_set_log_function (client_log_func);
gnutls_global_set_log_level (6);
#endif
gnutls_certificate_allocate_credentials (&x509_cred);
#ifdef REHANDSHAKE
restart:
#endif
/* Initialize TLS session
*/
gnutls_init (&session, GNUTLS_CLIENT);
gnutls_session_set_ptr(session, test);
cli_session = session;
/* Use default priorities */
if ((ret=gnutls_priority_set_direct (session, prio, &err)) < 0) {
fprintf(stderr, "Error in priority string %s: %s\n", gnutls_strerror(ret), err);
exit(1);
}
/* put the anonymous credentials to the current session
*/
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, x509_cred);
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) fd);
/* Perform the TLS handshake
*/
do
{
ret = gnutls_handshake (session);
}
while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
if (ret < 0)
{
fprintf (stderr, "client: Handshake failed\n");
gnutls_perror (ret);
exit(1);
}
ret = gnutls_protocol_get_version(session);
if (ret < GNUTLS_TLS1_1)
{
fprintf (stderr, "client: Handshake didn't negotiate TLS 1.1 (or later)\n");
exit(1);
}
gnutls_transport_set_push_function (session, push_crippled);
#ifndef REHANDSHAKE
restart:
#endif
do {
ret = gnutls_record_send (session, text, sizeof(text));
} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
/* measure peer's processing time */
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
#define TLS_RECV
#ifdef TLS_RECV
do {
ret = gnutls_record_recv(session, buffer, sizeof(buffer));
} while(ret < 0 && (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED));
#else
do {
ret = recv(fd, buffer, sizeof(buffer), 0);
} while(ret == -1 && errno == EAGAIN);
#endif
if (taken < MAX_MEASUREMENTS(test->npoints) && ret > 0)
{
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &stop);
taken++;
measurement = timespec_sub_ns(&stop, &start);
prev_point_ptr->measurements[prev_point_ptr->midx] = measurement;
/*fprintf(stderr, "(%u,%u): %lu\n", (unsigned) prev_point_ptr->byte1,
(unsigned) prev_point_ptr->byte2, measurements[taken]);*/
memcpy(&measurement, buffer, sizeof(measurement));
prev_point_ptr->smeasurements[prev_point_ptr->midx] = measurement;
prev_point_ptr->midx++;
/* read server's measurement */
#ifdef REHANDSHAKE
gnutls_deinit(session);
#endif
goto restart;
}
#ifndef TLS_RECV
else if (ret < 0)
{
fprintf(stderr, "Error in recv()\n");
exit(1);
}
#endif
gnutls_transport_set_push_function (session, push);
gnutls_bye (session, GNUTLS_SHUT_WR);
{
double avg2, med, savg, smed;
unsigned i;
FILE* fp = NULL;
if (test->file)
fp = fopen(test->file, "w");
if (fp) /* point, avg, median */
fprintf(fp, "Delta,TimeAvg,TimeMedian,ServerAvg,ServerMedian\n");
for (i=0;i<test->npoints;i++)
{
qsort( test->points[i].measurements, test->points[i].midx,
sizeof(test->points[i].measurements[0]), compar);
qsort( test->points[i].smeasurements, test->points[i].midx,
sizeof(test->points[i].smeasurements[0]), compar);
avg2 = calc_avg( test->points[i].measurements, test->points[i].midx);
/*var = calc_var( test->points[i].measurements, test->points[i].midx, avg2);*/
med = calc_median( test->points[i].measurements, test->points[i].midx);
savg = calc_avg( test->points[i].smeasurements, test->points[i].midx);
/*var = calc_var( test->points[i].measurements, test->points[i].midx, avg2);*/
smed = calc_median( test->points[i].smeasurements, test->points[i].midx);
/*min = calc_min( test->points[i].measurements, test->points[i].midx);*/
if (fp) /* point, avg, median */
fprintf(fp, "%u,%.2lf,%.2lf,%.2lf,%.2lf\n", (unsigned)test->points[i].byte1,
avg2,med,savg, smed);
/*printf("(%u) Avg: %.3f nanosec, Median: %.3f, Variance: %.3f\n", (unsigned)test->points[i].byte1,
avg2, med, var);*/
}
if (fp)
fclose(fp);
}
if (test->desc)
fprintf(stderr, "Description: %s\n", test->desc);
close (fd);
gnutls_deinit (session);
gnutls_certificate_free_credentials (x509_cred);
gnutls_global_deinit ();
}
