WiggleIterator * EntropyReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
int i;
int count = 0;
for (i = 0; i < multi->count; i++) {
if (isnan(multi->default_values[i])) {
count = -1;
break;
}
if (multi->default_values[i] != 0)
count++;
}
double default_value;
if (count == -1)
default_value = NAN;
else {
double p = count / multi->count;
if (p)
default_value = - p * log(p) - (1-p) * log(1 - p);
else
default_value = 0;
}
return newWiggleIterator(data, &StdDevReductionPop, &WiggleReducerSeek, default_value);
}
WiggleIterator * StdDevReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
int i;
double sum = 0;
for (i = 0; i < multi->count; i++) {
if (isnan(data->multi->default_values[i])) {
sum = NAN;
break;
}
sum += data->multi->default_values[i];
}
double default_value;
if (isnan(sum))
default_value = NAN;
else {
double mean = sum / multi->count;
double error = 0;
for (i = 0; i < multi->count; i++)
error += (data->multi->default_values[i] - mean) * (data->multi->default_values[i] - mean);
default_value = sqrt(error/multi->count);
}
return newWiggleIterator(data, &StdDevReductionPop, &WiggleReducerSeek, default_value);
}
WiggleIterator * BigBedReader(char * f, bool holdFire) {
BigBedReaderData * data = (BigBedReaderData *) calloc(1, sizeof(BigBedReaderData));
openBigBed(data, f, holdFire);
WiggleIterator * res = newWiggleIterator(data, &BigBedReaderPop, &BigBedReaderSeek, 0);
res->overlaps = true;
return res;
}
WiggleIterator * CVReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
int i;
double mean = 0;
for (i = 0; i < multi->count; i++) {
if ( isnan(multi->default_values[i])) {
mean = NAN;
break;
}
mean += multi->default_values[i];
}
float default_value;
if (!isnan(mean)) {
mean /= multi->count;
double error = 0;
for (i = 0; i < multi->count; i++)
error += (mean - multi->default_values[i]) * (mean - multi->default_values[i]);
default_value = sqrt(error/multi->count)/mean;
} else
default_value = NAN;
return newWiggleIterator(data, &CVReductionPop, &WiggleReducerSeek, default_value);
}
WiggleIterator * BamReader(char * filename, bool holdFire) {
BamReaderData * data = (BamReaderData *) calloc(1, sizeof(BamReaderData));
setSamtoolsDefaultConf(data);
OpenBamFile(data, filename);
if (!holdFire)
launchBufferedReader(&downloadBamFile, data, &(data->bufferedReaderData));
return newWiggleIterator(data, &BamReaderPop, &BamReaderSeek, 0);
}
WiggleIterator * TTestReduction(Multiset * multi) {
SetComparisonData * data = (SetComparisonData *) calloc(1, sizeof(SetComparisonData));
if (multi->count != 2 || multi->multis[0]->count + multi->multis[1]->count < 3) {
puts("The t-test function only works for two sets with enough elements to compute variance");
exit(1);
}
data->multi = multi;
return newWiggleIterator(data, &TTestReductionPop, &SetComparisonSeek);
}
WiggleIterator * FillInReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
if (multi->count != 2) {
printf("The fill in operator can only work on 2 iterators! Got %i\n", multi->count);
exit(1);
}
data->multi = multi;
WiggleIterator * res = newWiggleIterator(data, &FillInReductionPop, &WiggleReducerSeek, multi->default_values[1]);
return res;
}
WiggleIterator * BinaryFileReader(char * f) {
BinaryFileReaderData * data = (BinaryFileReaderData *) calloc(1, sizeof(BinaryFileReaderData));
data->file = fopen(f, "rb");
if (!data->file) {
fprintf(stderr, "Could not open %s\n", f);
exit(1);
}
launchDownloader(data);
BinaryFileReaderEnterBlock(data);
return newWiggleIterator(data, &BinaryFileReaderPop, &BinaryFileReaderSeek);
}
WiggleIterator * VcfReader(char * filename) {
VcfReaderData * data = (VcfReaderData *) calloc(1, sizeof(VcfReaderData));
data->filename = filename;
data->stop = -1;
if (!(data->file = fopen(filename, "r"))) {
fprintf(stderr, "Could not open bed file %s\n", filename);
exit(1);
}
WiggleIterator * res = newWiggleIterator(data, &VcfReaderPop, &VcfReaderSeek);
res->value = 1;
res->overlaps = true;
return res;
}
WiggleIterator * WiggleReader(char * f) {
WiggleReaderData * data = (WiggleReaderData *) calloc(1, sizeof(WiggleReaderData));
data->filename = f;
if (strcmp(f, "-")) {
if (!(data->file = fopen(f, "r"))) {
fprintf(stderr, "Could not open input file %s\n", f);
exit(1);
}
} else
data->file = stdin;
data->readingMode = BED_GRAPH;
data->stop = -1;
return CompressionWiggleIterator(newWiggleIterator(data, &WiggleReaderPop, &WiggleReaderSeek));
}
WiggleIterator * SumReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
int i;
double sum = 0;
for (i = 0; i < multi->count; i++) {
if (isnan(data->multi->default_values[i])) {
sum = NAN;
break;
}
sum += data->multi->default_values[i];
}
return newWiggleIterator(data, &SumReductionPop, &WiggleReducerSeek, sum);
}
WiggleIterator * ProductReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
int i;
double prod = 1;
for (i = 0; i < multi->count; i++) {
if (isnan(data->multi->default_values[i])) {
prod = NAN;
break;
}
prod *= data->multi->default_values[i];
}
return newWiggleIterator(data, &ProductReductionPop, &WiggleReducerSeek, prod);
}
WiggleIterator * MinReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
int i;
double min = data->multi->default_values[0];
if (!isnan(min)) {
for (i = 1; i < multi->count; i++) {
if (isnan(data->multi->default_values[i])) {
min = NAN;
break;
}
if (data->multi->default_values[i] < min)
min = data->multi->default_values[i];
}
}
return newWiggleIterator(data, &MinReductionPop, &WiggleReducerSeek, min);
}
WiggleIterator * MWUReduction(Multiset * multi) {
MWUData * data = (MWUData *) calloc(1, sizeof(MWUData));
if (multi->count != 2 || multi->multis[0]->count == 0 || multi->multis[1]->count == 0) {
puts("The Mann-Whitney U function only works for two non-empty sets");
exit(1);
}
data->multi = multi;
data->n1 = multi->multis[0]->count;
data->n2 = multi->multis[1]->count;
data->N = data->n1 + data->n2;
data->rankingTable = calloc(data->N, sizeof(ValueSetPair));
if (true) {
// Ideally, tables could be used for small values of n1 and n2
data->normalApproximation = true;
data->mu_U = data->n1 * data->n2 / 2;
data->sigma_U = sqrt(data->n1 * data->n2 * (data->n1 + data->n2 + 1) / 12);
}
return newWiggleIterator(data, &MWUReductionPop, &MWUSeek);
}
WiggleIterator * MeanReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
int i;
double sum = 0;
for (i = 0; i < multi->count; i++) {
if (isnan(data->multi->default_values[i])) {
sum = NAN;
break;
}
sum += data->multi->default_values[i];
}
float default_value;
if (isnan(sum))
default_value = NAN;
else
default_value = sum/multi->count;
return newWiggleIterator(data, &MeanReductionPop, &WiggleReducerSeek, default_value);
}
WiggleIterator * MedianReduction(Multiplexer * multi) {
MedianWiggleReducerData * data = (MedianWiggleReducerData *) calloc(1, sizeof(MedianWiggleReducerData));
data->multi = multi;
data->vals = (double *) calloc(data->multi->count, sizeof(double));
int i;
float default_value = 0;
for (i = 0; i < multi->count; i++) {
data->vals[i] = multi->default_values[i];
if (isnan(data->vals[i])) {
default_value = NAN;
break;
}
}
if (!isnan(default_value)) {
qsort(data->vals, multi->count, sizeof(double), &compDoubles);
default_value = data->vals[multi->count/2];
}
return newWiggleIterator(data, &MedianReductionPop, &MedianWiggleReducerSeek, default_value);
}
WiggleIterator * CVReduction(Multiplexer * multi) {
WiggleReducerData * data = (WiggleReducerData *) calloc(1, sizeof(WiggleReducerData));
data->multi = multi;
return newWiggleIterator(data, &CVReductionPop, &WiggleReducerSeek);
}
WiggleIterator * BcfReader(char * filename) {
BCFReaderData * data = (BCFReaderData *) calloc(1, sizeof(BCFReaderData));
OpenTabixFile(data, filename);
launchBufferedReader(&downloadTabixFile, data, &(data->bufferedReaderData));
return newWiggleIterator(data, &BCFReaderPop, &BcfReaderSeek);
}
WiggleIterator * MedianReduction(Multiplexer * multi) {
MedianWiggleReducerData * data = (MedianWiggleReducerData *) calloc(1, sizeof(MedianWiggleReducerData));
data->multi = multi;
data->vals = (double *) calloc(data->multi->count, sizeof(double));
return newWiggleIterator(data, &MedianReductionPop, &MedianWiggleReducerSeek);
}
WiggleIterator * SelectReduction(Multiplexer * multi, int index) {
WiggleSelectData * data = (WiggleSelectData *) calloc(1, sizeof(WiggleSelectData));
data->multi = multi;
data->index = index;
return newWiggleIterator(data, &SelectReductionPop, &WiggleReducerSeek, multi->default_values[index]);
}
