void MedianReductionPop(WiggleIterator * wi) {
int i;
if (wi->done)
return;
MedianWiggleReducerData * data = (MedianWiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
for (i = 0; i < multi->count; i++) {
if (multi->inplay[i])
data->vals[i] = multi->values[i];
else
data->vals[i] = multi->default_values[i];
if (isnan(data->vals[i])) {
wi->value = NAN;
popMultiplexer(multi);
return;
}
}
qsort(data->vals, multi->count, sizeof(double), &compDoubles);
wi->value = data->vals[multi->count / 2];
popMultiplexer(multi);
}
void SelectReductionPop(WiggleIterator * wi) {
if (wi->done)
return;
WiggleSelectData * data = (WiggleSelectData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
while (!multi->inplay[data->index]) {
popMultiplexer(multi);
if (multi->done) {
wi->done = true;
return;
}
}
wi->value = multi->values[data->index];
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
popMultiplexer(multi);
}
void CVReductionPop(WiggleIterator * wi) {
int i;
double mean, diff;
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
mean = 0;
for (i = 0; i < multi->count; i++) {
float value;
if (multi->inplay[i])
value = multi->values[i];
else
value = multi->default_values[i];
if (isnan(value)) {
wi->value = NAN;
popMultiplexer(multi);
return;
}
}
mean /= multi->count;
if (mean == 0) {
wi->value = NAN;
popMultiplexer(multi);
return;
}
wi->value = 0;
for (i = 0; i < multi->count; i++) {
if (multi->inplay[i])
diff = mean - multi->values[i];
else
diff = mean - multi->default_values[i];
wi->value += diff * diff;
}
wi->value /= multi->count;
wi->value = sqrt(wi->value) / mean;
popMultiplexer(multi);
}
void ProductReductionPop(WiggleIterator * wi) {
int i;
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
wi->value = 1;
for (i = 0; i < multi->count; i++) {
double value;
if (multi->inplay[i])
value = multi->values[i];
else
value = multi->default_values[i];
if (isnan(value)) {
wi->value = NAN;
break;
}
wi->value *= value;
}
popMultiplexer(multi);
}
void MaxReductionPop(WiggleIterator * wi) {
int i;
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
if (multi->inplay[0])
wi->value = multi->iters[0]->value;
else
wi->value = 0;
for (i = 1; i < multi->count; i++) {
double value;
if (multi->inplay[i])
value = multi->values[i];
else
value = multi->iters[i]->default_value;
if (wi->value < value)
wi->value = value;
}
popMultiplexer(multi);
}
void EntropyReductionPop(WiggleIterator * wi) {
int i;
float count = 0;
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
for (i = 0; i < multi->count; i++)
if ((multi->inplay[i] && multi->values[i] != 0) || (!multi->inplay[i] && multi->iters[i]->default_value != 0))
count++;
if (count == 0 || count == multi->count)
wi->value = 0;
else {
double p = count / multi->count;
wi->value = - p * log(p) - (1-p) * log(1 - p);
}
popMultiplexer(multi);
}
void MeanReductionPop(WiggleIterator * wi) {
int i;
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
wi->value = 0;
for (i = 0; i < multi->count; i++)
if (multi->inplay[i])
wi->value += multi->values[i];
else
wi->value += multi->iters[i]->default_value;
wi->value /= multi->count;
popMultiplexer(multi);
}
static void TeeMultiplexerSeek(Multiplexer * multi, const char * chrom, int start, int finish) {
TeeMultiplexerData * data = (TeeMultiplexerData *) multi->data;
killWriter(data);
fflush(data->outfile);
seekMultiplexer(data->in, chrom, start, finish);
multi->done = false;
launchWriter(data, multi->count);
popMultiplexer(multi);
}
void EntropyReductionPop(WiggleIterator * wi) {
int i;
float count = 0;
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
for (i = 0; i < multi->count; i++) {
double value;
if (multi->inplay[i])
value = multi->values[i];
else
value = multi->default_values[i];
if (isnan(value)) {
wi->value = NAN;
popMultiplexer(multi);
return;
} else if (value > 0)
count++;
}
if (count == 0 || count == multi->count)
wi->value = 0;
else {
double p = count / multi->count;
wi->value = - p * log(p) - (1-p) * log(1 - p);
}
popMultiplexer(multi);
}
bool CVReductionPop2(WiggleIterator * wi) {
int i;
double mean, diff;
if (wi->done)
return true;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return false;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
mean = 0;
for (i = 0; i < multi->count; i++)
if (multi->inplay[i])
mean += multi->values[i];
mean /= multi->count;
if (mean == 0) {
popMultiplexer(multi);
return true;
}
wi->value = 0;
for (i = 0; i < multi->count; i++) {
if (multi->inplay[i])
diff = mean - multi->values[i];
else
diff = mean - multi->iters[i]->default_value;
wi->value += diff * diff;
}
wi->value /= multi->count;
wi->value = sqrt(wi->value) / mean;
popMultiplexer(multi);
return false;
}
static void seekCoreMultiplexer(Multiplexer * multi, const char * chrom, int start, int finish) {
int i;
multi->done = false;
for (i=0; i<multi->count; i++)
seek(multi->iters[i], chrom, start, finish);
fh_deleteheap(multi->starts);
fh_deleteheap(multi->finishes);
multi->starts = fh_makeheap();
multi->finishes = fh_makeheap();
multi->inplay_count = 0;
popMultiplexer(multi);
}
void VarianceReductionPop(WiggleIterator * wi) {
int i;
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
double mean = 0;
double count = 0;
for (i = 0; i < multi->count; i++) {
float value;
if (multi->inplay[i])
value = multi->values[i];
else
value = multi->default_values[i];
if (isnan(value)) {
mean = NAN;
break;
}
mean += value;
count++;
}
if (count < 2 || isnan(mean)) {
wi->value = NAN;
} else {
mean /= count;
wi->value = 0;
for (i = 0; i < multi->count; i++) {
if (multi->inplay[i]) {
double diff = mean - multi->values[i];
wi->value += diff * diff;
}
}
wi->value /= count;
}
popMultiplexer(multi);
}
Multiplexer * TeeMultiplexer(Multiplexer * in, FILE * outfile, bool bedGraph, bool holdFire) {
TeeMultiplexerData * data = (TeeMultiplexerData *) calloc(1, sizeof(TeeMultiplexerData));
data->in = in;
data->outfile = outfile;
data->bedGraph = bedGraph;
// Hold fire means that you wait for the first seek before doing any writing
if (!holdFire)
launchWriter(data, in->count);
Multiplexer * res = newCoreMultiplexer(data, in->count, &TeeMultiplexerPop, &TeeMultiplexerSeek);
res->values = in->values;
res->inplay = in->inplay;
res->default_values = in->default_values;
popMultiplexer(res);
return res;
}
static void TeeMultiplexerPop(Multiplexer * multi) {
TeeMultiplexerData * data = (TeeMultiplexerData *) multi->data;
Multiplexer * in = data->in;
if (!data->in->done) {
multi->chrom = in->chrom;
multi->start = in->start;
multi->finish = in->finish;
// No need to copy values, pointer points to the source multipliexers values' array
//multi->value = in->value;
if (data->threadID) {
int index = data->lastBlock->count;
data->lastBlock->chroms[index] = in->chrom;
data->lastBlock->starts[index] = in->start;
data->lastBlock->finishes[index] = in->finish;
int i;
double * ptr = data->lastBlock->values + (index * multi->count);
for (i = 0; i < multi->count; i++)
*(ptr++) = in->values[i];
if (++data->lastBlock->count >= BLOCK_LENGTH) {
// Communications
pthread_mutex_lock(&data->continue_mutex);
data->count++;
pthread_cond_signal(&data->continue_cond);
if (data->count > MAX_OUT_BLOCKS)
pthread_cond_wait(&data->continue_cond, &data->continue_mutex);
pthread_mutex_unlock(&data->continue_mutex);
data->lastBlock->next = (BlockData*) calloc(1, sizeof(BlockData));
data->lastBlock->next->values = (double*) calloc(BLOCK_LENGTH * multi->count, sizeof(double));
data->lastBlock->next->width = in->count;
data->lastBlock = data->lastBlock->next;
data->lastBlock->bedGraph = data->bedGraph;
}
}
popMultiplexer(in);
} else if (data->threadID) {
pthread_mutex_lock(&data->continue_mutex);
data->count++;
data->done = true;
pthread_cond_signal(&data->continue_cond);
pthread_mutex_unlock(&data->continue_mutex);
multi->done = true;
pthread_join(data->threadID, NULL);
}
}
void FillInReductionPop(WiggleIterator * wi) {
if (wi->done)
return;
WiggleReducerData * data = (WiggleReducerData *) wi->data;
Multiplexer * multi = data->multi;
if (multi->done) {
wi->done = true;
return;
}
wi->chrom = multi->chrom;
wi->start = multi->start;
wi->finish = multi->finish;
if (multi->inplay[1])
wi->value = multi->values[1];
else
wi->value = multi->default_values[1];
popMultiplexer(multi);
}
