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]); }