/*
* calc_kmeans
* The main body of kmean calculation.
* inputs : all of elements to be clustered by kmeans
* dim : dimension of element, namely myvector has dim floats in each.
* N : the number of input vectors
* k : the number to cluster
* mean : initial mean vectors (centroids)
* r : (out) an array to put answer cluster ids
*/
static int *
calc_kmeans(myvector inputs, int dim, int N, int k, myvector mean, int *r)
{
float8 target, new_target;
/*
* initialize purpose value. At this time, r doesn't mean anything
* but it's ok; just fill target by some value.
*/
target = J(inputs, dim, N, k, mean, r);
for (;;)
{
/* it's good to check here, for avoid infinite loop */
CHECK_FOR_INTERRUPTS();
update_r(inputs, dim, N, k, mean, r);
update_mean(inputs, dim, N, k, mean, r);
new_target = J(inputs, dim, N, k, mean, r);
kmeans_debug(mean, dim, k);
/*
* if all the classification stay, diff must be 0.0,
* which means we can go out!
*/
if (target == new_target)
break;
target = new_target;
}
return r;
}
void update(struct mlogit *m)
{
if (uintset_count(&m->ind)) {
update_dx(m);
update_dist(m);
update_mean(m);
update_cov(m);
uintset_clear(&m->ind);
}
}
void GROUP::push(Node n , int curFE)
{
Node tmp(length);
LastModifiedFE = curFE;
tmp.allele = n.allele;
tmp.fitness = n.fitness;
tmp.isEvaluated = true;
nodes.push_back(tmp);
sum += n.fitness;
sum2+= n.fitness * n.fitness;
AllUsedNumber ++ ;
update_mean();
max = getmax();
return ;
}
void add_interarrival(interarrival_window_t* window, long interarrival) {
window_el_t *window_el;
window_el = calloc(1, sizeof(*window_el));
window_el->interarrival = interarrival;
if (!window->head) {
window->head = window_el;
window->tail = window_el;
} else {
window->tail->next = window_el;
}
window->size++;
window_el_t *removed = NULL;
if (window->size > MAX_SIZE) {
removed = window->head;
window->head = removed->next;
window->size--;
}
update_mean(window, window_el, removed);
free(removed);
}
static void measure(int fd, struct flow *fw)
{
long delay;
fw->written_blocks++;
fw->total_written += fw->block_size;
if (fw->written_blocks < fw->blocks_per_delay)
return;
assert(!fdatasync(fd));
assert(!gettimeofday(&fw->t2, NULL));
/* Help the kernel to help us. */
assert(!posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED));
delay = delay_ms(&fw->t1, &fw->t2);
switch (fw->state) {
case FW_INC:
if (delay > fw->delay_ms) {
move_to_search(fw,
fw->blocks_per_delay - fw->step / 2,
fw->blocks_per_delay);
} else if (delay < fw->delay_ms) {
inc_step(fw);
} else
move_to_steady(fw);
break;
case FW_DEC:
if (delay > fw->delay_ms) {
dec_step(fw);
} else if (delay < fw->delay_ms) {
move_to_search(fw, fw->blocks_per_delay,
fw->blocks_per_delay + fw->step / 2);
} else
move_to_steady(fw);
break;
case FW_SEARCH:
if (fw->bpd2 - fw->bpd1 <= 3) {
move_to_steady(fw);
break;
}
if (delay > fw->delay_ms) {
fw->bpd2 = fw->blocks_per_delay;
fw->blocks_per_delay = (fw->bpd1 + fw->bpd2) / 2;
} else if (delay < fw->delay_ms) {
fw->bpd1 = fw->blocks_per_delay;
fw->blocks_per_delay = (fw->bpd1 + fw->bpd2) / 2;
} else
move_to_steady(fw);
break;
case FW_STEADY:
update_mean(fw);
if (delay <= fw->delay_ms) {
move_to_inc(fw);
}
else if (fw->blocks_per_delay > 1) {
move_to_dec(fw);
}
break;
default:
assert(0);
}
if (fw->progress) {
/* Instantaneous speed. */
double inst_speed =
(double)fw->blocks_per_delay * fw->block_size * 1000 /
fw->delay_ms;
const char *unit = adjust_unit(&inst_speed);
double percent;
/* The following shouldn't be necessary, but sometimes
* the initial free space isn't exactly reported
* by the kernel; this issue has been seen on Macs.
*/
if (fw->total_size < fw->total_written)
fw->total_size = fw->total_written;
percent = (double)fw->total_written * 100 / fw->total_size;
erase(fw->erase);
fw->erase = printf("%.2f%% -- %.2f %s/s",
percent, inst_speed, unit);
assert(fw->erase > 0);
if (fw->measurements > 0)
fw->erase += pr_time(
(fw->total_size - fw->total_written) /
get_avg_speed(fw));
fflush(stdout);
}
start_measurement(fw);
}
static inline void move_to_steady(struct flow *fw)
{
update_mean(fw);
fw->state = FW_STEADY;
}
