struct sample *groupByPosition(int grouping , struct sample *sampList) { struct sample *groupedList = NULL, *samp = NULL, *currSamp = NULL, *sampNext=NULL; int count = 0; for(samp = sampList; samp != NULL; samp = sampNext) { sampNext = samp->next; AllocVar(currSamp); currSamp->chrom = cloneString(samp->chrom); currSamp->chromStart = samp->chromStart; currSamp->name = cloneString(samp->name); snprintf(currSamp->strand, sizeof(currSamp->strand), "%s", samp->strand); AllocArray(currSamp->samplePosition, grouping); AllocArray(currSamp->sampleHeight, grouping); count = 0; while(samp != NULL && count < grouping && sameString(samp->chrom,currSamp->chrom)) { addSampleToCurrent(currSamp, samp, grouping); count += samp->sampleCount; samp = sampNext = samp->next; } if(count != 0) currSamp->score = currSamp->score / count; currSamp->chromEnd = currSamp->chromStart + currSamp->samplePosition[count -1]; slAddHead(&groupedList, currSamp); } slReverse(&groupedList); return groupedList; }
struct cdsEvidence *createCds(struct dnaSeq *seq, int start, int end, int *upAtgCount, int *upKozakCount, int lastIntronPos, struct orthoCdsArray *orthoList, double orthoWeightPer) /* Return new cdsEvidence on given sequence at given position. */ { struct cdsEvidence *orf; AllocVar(orf); int size = end - start; size -= size % 3; end = start + size; orf->name = cloneString(seq->name); orf->start = start; orf->end = end; orf->source = cloneString("txCdsPredict"); orf->accession = cloneString("."); orf->score = orfScore(orf, seq, upAtgCount, upKozakCount, lastIntronPos, orthoList, orthoWeightPer); orf->startComplete = startsWith("atg", seq->dna + start); orf->endComplete = isStopCodon(seq->dna + end - 3); orf->cdsCount = 1; AllocArray(orf->cdsStarts, 1); orf->cdsStarts[0] = start; AllocArray(orf->cdsSizes, 1); orf->cdsSizes[0] = size; return orf; }
void initTitleHelper(struct titleHelper *th, char *track, int startIx, int centerIx, int endIx, int nRecords, struct vcfFile *vcff) /* Set up info including arrays of ref & alt alleles for cluster mouseover. */ { th->track = track; th->startIx = startIx; th->centerIx = centerIx; th->endIx = endIx; th->nRecords = nRecords; int len = endIx - startIx; AllocArray(th->refs, len); AllocArray(th->alts, len); struct vcfRecord *rec; int i; for (rec = vcff->records, i = 0; rec != NULL && i < endIx; rec = rec->next, i++) { if (i < startIx) continue; char refAl[16]; abbrevAndHandleRC(refAl, sizeof(refAl), rec->alleles[0]); th->refs[i-startIx] = vcfFilePooledStr(vcff, refAl); char altAl1[16]; abbrevAndHandleRC(altAl1, sizeof(altAl1), rec->alleles[1]); tolowers(altAl1); th->alts[i-startIx] = vcfFilePooledStr(vcff, altAl1); } }
struct sample *sampFromAffyPair(struct affyPairs *ap, struct hash *liftHash) /* Use the data in the affy pair and the offset info in the hash to make a sample data type. */ { struct sample *samp = NULL; struct liftSpec *lf = NULL; char *name = contigFromAffyPairName(ap->probeSet); float score = 0; if(name != NULL) { lf = hashFindVal(liftHash, name); freez(&name); } if(lf != NULL) { AllocVar(samp); samp->chrom = cloneString(lf->newName); samp->chromStart = samp->chromEnd = ap->pos + lf->offset; samp->name = cloneString("a"); score = (ap->pm) - (ap->mm); if(score < 1) score = 1; samp->score = (int)score; sprintf(samp->strand, "+"); samp->sampleCount = 1; AllocArray(samp->samplePosition, samp->sampleCount); samp->samplePosition[0] = 0; AllocArray(samp->sampleHeight, samp->sampleCount); samp->sampleHeight[0] = samp->score; } return samp; }
struct sample *avgSamples(struct sample *s1, struct sample *s2, struct sample *s3, int expIndex, int index) { struct sample *ret = NULL; //, *s1, *s2, *s3; int i; /* s1 = (struct sample *)slElementFromIx(sList1, index); */ /* s2 = (struct sample *)slElementFromIx(sList2, index); */ /* s3 = (struct sample *)slElementFromIx(sList3, index); */ AllocVar(ret); ret->chrom = cloneString(s1->chrom); ret->chromStart = s1->chromStart; ret->chromEnd = s1->chromEnd; ret->name = getNameForExp(expIndex); snprintf(ret->strand, sizeof(ret->strand), "%s", s1->strand); ret->sampleCount = s1->sampleCount; AllocArray(ret->samplePosition, ret->sampleCount); AllocArray(ret->sampleHeight, ret->sampleCount); ret->score = (s1->score + s2->score + s3->score)/3; for(i=0;i<ret->sampleCount; i++) { ret->samplePosition[i] = s1->samplePosition[i]; if(!((s1->samplePosition[i] == s2->samplePosition[i]) && (s2->samplePosition[i] == s3->samplePosition[i]))) errAbort("avgTranscriptomeExps::avgSamples() - for probe %s:%d-%d positions at index %i don't agree. %d, %d, %d", ret->chrom, ret->chromStart, ret->chromEnd, i, s1->samplePosition[i], s2->samplePosition[i], s3->samplePosition[i]); ret->sampleHeight[i] = (s1->sampleHeight[i] + s2->sampleHeight[i] + s3->sampleHeight[i])/3; } return ret; }
struct snp125CodingCoordless *snp125CodingCoordlessCommaIn(char **pS, struct snp125CodingCoordless *ret) /* Create a snp125CodingCoordless out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new snp125CodingCoordless */ { char *s = *pS; if (ret == NULL) AllocVar(ret); ret->name = sqlStringComma(&s); ret->transcript = sqlStringComma(&s); ret->frame = sqlEnumComma(&s, values_frame, &valhash_frame); ret->alleleCount = sqlSignedComma(&s); { int i; s = sqlEatChar(s, '{'); AllocArray(ret->funcCodes, ret->alleleCount); for (i=0; i<ret->alleleCount; ++i) { ret->funcCodes[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } { int i; s = sqlEatChar(s, '{'); AllocArray(ret->alleles, ret->alleleCount); for (i=0; i<ret->alleleCount; ++i) { ret->alleles[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } { int i; s = sqlEatChar(s, '{'); AllocArray(ret->codons, ret->alleleCount); for (i=0; i<ret->alleleCount; ++i) { ret->codons[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } { int i; s = sqlEatChar(s, '{'); AllocArray(ret->peptides, ret->alleleCount); for (i=0; i<ret->alleleCount; ++i) { ret->peptides[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } *pS = s; return ret; }
struct bed *bedForIv(struct intronEv *iv) /** Make a bed to represent a intronEv structure. */ { struct bed *bed = NULL; AllocVar(bed); bed->chrom = cloneString(iv->chrom); bed->chromStart = bed->thickStart = iv->e1S; bed->chromEnd = bed->thickEnd = iv->e2E; bed->name = cloneString(iv->ev->orthoBed->name); if(iv->orientation == 1) safef(bed->strand, sizeof(bed->strand), "+"); else if(iv->orientation == -1) safef(bed->strand, sizeof(bed->strand), "-"); else safef(bed->strand, sizeof(bed->strand), "%s", iv->ev->orthoBed->strand); bed->blockCount = 2; AllocArray(bed->chromStarts, 2); bed->chromStarts[0] = iv->e1S - bed->chromStart; bed->chromStarts[1] = iv->e2S - bed->chromStart; AllocArray(bed->blockSizes, 2); bed->blockSizes[0] = iv->e1E - iv->e1S; bed->blockSizes[1] = iv->e2E - iv->e2S; bed->score = scoreForIntronEv(iv); return bed; }
void bitmapToMaskArray(struct hash *bitmapHash, struct hash *tbHash) /* Translate each bitmap in bitmapHash into an array of mask coordinates * in the corresponding twoBit in tbHash. Assume tbHash's mask array is * empty at the start -- we allocate it here. Free bitmap when done. */ { struct hashCookie cookie = hashFirst(tbHash); struct hashEl *hel = NULL; while ((hel = hashNext(&cookie)) != NULL) { char *seqName = hel->name; struct twoBit *tb = (struct twoBit *)(hel->val); struct hashEl *bHel = hashLookup(bitmapHash, seqName); Bits *bits; unsigned start=0, end=0; assert(tb != NULL); assert(tb->maskBlockCount == 0); if (bHel == NULL) errAbort("Missing bitmap for seq \"%s\"", seqName); bits = (Bits *)bHel->val; if (bits != NULL) { struct lm *lm = lmInit(0); struct unsignedRange *rangeList = NULL, *range = NULL; int i; for (;;) { start = bitFindSet(bits, end, tb->size); if (start >= tb->size) break; end = bitFindClear(bits, start, tb->size); if (end > start) { lmAllocVar(lm, range); range->start = start; range->size = (end - start); slAddHead(&rangeList, range); } } slReverse(&rangeList); tb->maskBlockCount = slCount(rangeList); if (tb->maskBlockCount > 0) { AllocArray(tb->maskStarts, tb->maskBlockCount); AllocArray(tb->maskSizes, tb->maskBlockCount); for (i = 0, range = rangeList; range != NULL; i++, range = range->next) { tb->maskStarts[i] = range->start; tb->maskSizes[i] = range->size; } } lmCleanup(&lm); bitFree(&bits); bHel->val = NULL; } } }
void dbFindFieldsWith(char *database, char *regExp, char *output) /* dbFindFieldsWith - Look through database and find fields that have elements matching a certain pattern in the first N rows.. */ { regex_t re; int err = regcomp(&re, regExp, REG_NOSUB|REG_EXTENDED); if (err < 0) errAbort("regcomp failed code %d", err); struct sqlConnection *conn = sqlConnect(database); struct slName *table, *tableList = sqlQuickList(conn, "NOSQLINJ show tables"); FILE *f = mustOpen(output, "w"); for (table = tableList; table != NULL; table = table->next) { char query[256]; sqlSafef(query, sizeof(query), "select * from %s limit %d", table->name, maxRows); verbose(2, "%s.%s\n", database, table->name); struct sqlResult *sr = sqlGetResult(conn, query); if (sr != NULL) { int colCount = sqlCountColumns(sr); /* Get labels for columns */ char **labels; AllocArray(labels, colCount); int i; for (i=0; i<colCount; ++i) labels[i] = sqlFieldName(sr); /* Get flags that say which fields we've reported. */ bool *flags; AllocArray(flags, colCount); char **row; while ((row = sqlNextRow(sr)) != NULL) { int i; for (i=0; i<colCount; ++i) { char *field = row[i]; if (field != NULL && field[0] != 0) { if (regexec(&re, row[i], 0, NULL, 0) == 0) { if (!flags[i]) { flags[i] = TRUE; fprintf(f, "%s\t%s\t%s\n", table->name, labels[i], row[i]); } } } } } sqlFreeResult(&sr); freez(&flags); freez(&labels); } } carefulClose(&f); }
struct cutter *cutterCommaIn(char **pS, struct cutter *ret) /* Create a cutter out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new cutter */ { char *s = *pS; if (ret == NULL) AllocVar(ret); ret->name = sqlStringComma(&s); ret->size = sqlUnsignedComma(&s); ret->matchSize = sqlUnsignedComma(&s); ret->seq = sqlStringComma(&s); ret->cut = sqlUnsignedComma(&s); ret->overhang = sqlSignedComma(&s); ret->palindromic = sqlUnsignedComma(&s); ret->semicolon = sqlUnsignedComma(&s); ret->numSciz = sqlUnsignedComma(&s); { int i; s = sqlEatChar(s, '{'); AllocArray(ret->scizs, ret->numSciz); for (i=0; i<ret->numSciz; ++i) { ret->scizs[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } ret->numCompanies = sqlUnsignedComma(&s); { int i; s = sqlEatChar(s, '{'); AllocArray(ret->companies, ret->numCompanies); for (i=0; i<ret->numCompanies; ++i) { ret->companies[i] = sqlCharComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } ret->numRefs = sqlUnsignedComma(&s); { int i; s = sqlEatChar(s, '{'); AllocArray(ret->refs, ret->numRefs); for (i=0; i<ret->numRefs; ++i) { ret->refs[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } *pS = s; return ret; }
void avgTranscriptomeExps() { struct sample *s = NULL; struct sample *s1,*s2,*s3; struct sample *sList1, *sList2, *sList3 = NULL; struct sample **sArray1, **sArray2, **sArray3 = NULL; int i,j,k; FILE *out = NULL; for(i=1; i<12; i++) { for(j='a'; j<'d'; j++) { char buff[2048]; int count; struct sample *avgList = NULL, *avg; if((i != 6 || j != 'a') || doAll) { snprintf(buff, sizeof(buff), "%d.%c.1.%s", i,j,suffix); printf("Averaging %s\n", buff); sList1 = sampleLoadAll(buff); snprintf(buff, sizeof(buff), "%d.%c.2.%s", i,j,suffix); sList2 = sampleLoadAll(buff); snprintf(buff, sizeof(buff), "%d.%c.3.%s", i,j,suffix); sList3 = sampleLoadAll(buff); count = slCount(sList1); AllocArray(sArray1,count); AllocArray(sArray2,count); AllocArray(sArray3,count); for(k=0, s1=sList1, s2=sList2, s3=sList3; k<count; s1=s1->next,s2=s2->next,s3=s3->next, k++) { sArray1[k] = s1; sArray2[k] = s2; sArray3[k] = s3; } for(k=0;k<count; k++) { avg = avgSamples(sArray1[k], sArray2[k], sArray3[k], i, k); slAddHead(&avgList, avg); } slReverse(&avgList); snprintf(buff, sizeof(buff), "%d.%c.1.%s.avg", i,j,suffix); out = mustOpen(buff, "w"); for(s = avgList; s != NULL; s = s->next) sampleTabOut(s, out); carefulClose(&out); freez(&sArray1); freez(&sArray2); freez(&sArray3); sampleFreeList(&avgList); sampleFreeList(&sList1); sampleFreeList(&sList2); sampleFreeList(&sList3); } } } }
struct hgTranscript *hgTranscriptCommaIn(char **pS) /* Create a hgTranscript out of a comma separated string. */ { struct hgTranscript *ret; char *s = *pS; int i; AllocVar(ret); ret->id = sqlUnsignedComma(&s); ret->name = sqlStringComma(&s); ret->hgGene = sqlUnsignedComma(&s); ret->startBac = sqlUnsignedComma(&s); ret->startPos = sqlUnsignedComma(&s); ret->endBac = sqlUnsignedComma(&s); ret->endPos = sqlUnsignedComma(&s); ret->cdsStartBac = sqlUnsignedComma(&s); ret->cdsStartPos = sqlUnsignedComma(&s); ret->cdsEndBac = sqlUnsignedComma(&s); ret->cdsEndPos = sqlUnsignedComma(&s); ret->orientation = sqlSignedComma(&s); ret->exonCount = sqlUnsignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->exonStartBacs, ret->exonCount); for (i=0; i<ret->exonCount; ++i) { ret->exonStartBacs[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); s = sqlEatChar(s, '{'); AllocArray(ret->exonStartPos, ret->exonCount); for (i=0; i<ret->exonCount; ++i) { ret->exonStartPos[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); s = sqlEatChar(s, '{'); AllocArray(ret->exonEndBacs, ret->exonCount); for (i=0; i<ret->exonCount; ++i) { ret->exonEndBacs[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); s = sqlEatChar(s, '{'); AllocArray(ret->exonEndPos, ret->exonCount); for (i=0; i<ret->exonCount; ++i) { ret->exonEndPos[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); *pS = s; return ret; }
struct pslWQueryID *pslWQueryIDCommaIn(char **pS, struct pslWQueryID *ret) /* Create a pslWQueryID out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new pslWQueryID */ { char *s = *pS; int i; if (ret == NULL) AllocVar(ret); ret->matches = sqlUnsignedComma(&s); ret->misMatches = sqlUnsignedComma(&s); ret->repMatches = sqlUnsignedComma(&s); ret->nCount = sqlUnsignedComma(&s); ret->qNumInsert = sqlUnsignedComma(&s); ret->qBaseInsert = sqlUnsignedComma(&s); ret->tNumInsert = sqlUnsignedComma(&s); ret->tBaseInsert = sqlUnsignedComma(&s); sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand)); ret->qName = sqlStringComma(&s); ret->qSize = sqlUnsignedComma(&s); ret->qStart = sqlUnsignedComma(&s); ret->qEnd = sqlUnsignedComma(&s); ret->tName = sqlStringComma(&s); ret->tSize = sqlUnsignedComma(&s); ret->tStart = sqlUnsignedComma(&s); ret->tEnd = sqlUnsignedComma(&s); ret->blockCount = sqlUnsignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->blockSizes, ret->blockCount); for (i=0; i<ret->blockCount; ++i) { ret->blockSizes[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); s = sqlEatChar(s, '{'); AllocArray(ret->qStarts, ret->blockCount); for (i=0; i<ret->blockCount; ++i) { ret->qStarts[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); s = sqlEatChar(s, '{'); AllocArray(ret->tStarts, ret->blockCount); for (i=0; i<ret->blockCount; ++i) { ret->tStarts[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); ret->queryID = sqlStringComma(&s); *pS = s; return ret; }
struct altProbe *altProbeCommaIn(char **pS, struct altProbe *ret) /* Create a altProbe out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new altProbe */ { char *s = *pS; int i; if (ret == NULL) AllocVar(ret); ret->chrom = sqlStringComma(&s); ret->chromStart = sqlSignedComma(&s); ret->chromEnd = sqlSignedComma(&s); ret->type = sqlSignedComma(&s); sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand)); ret->name = sqlStringComma(&s); ret->maxCounts = sqlSignedComma(&s); ret->contProbeCount = sqlSignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->contProbeSets, ret->contProbeCount); for (i=0; i<ret->contProbeCount; ++i) { ret->contProbeSets[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); ret->alt1ProbeCount = sqlSignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->alt1ProbeSets, ret->alt1ProbeCount); for (i=0; i<ret->alt1ProbeCount; ++i) { ret->alt1ProbeSets[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); ret->alt2ProbeCount = sqlSignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->alt2ProbeSets, ret->alt2ProbeCount); for (i=0; i<ret->alt2ProbeCount; ++i) { ret->alt2ProbeSets[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); ret->transcriptCount = sqlSignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->transcriptNames, ret->transcriptCount); for (i=0; i<ret->transcriptCount; ++i) { ret->transcriptNames[i] = sqlStringComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); *pS = s; return ret; }
void fillInGene(struct chain *chain, struct genePred *gene, struct genePred **pGene) /** Fill in syntenic gene structure with initial information for gene. */ { FILE *cdsErrorFp; struct genePred *synGene = NULL; int qs, qe; struct chain *subChain=NULL, *toFree=NULL; AllocVar(synGene); chainSubSetForRegion(chain, gene->txStart, gene->txEnd , &subChain, &toFree); if(subChain == NULL) { *pGene= NULL; return; } qChainRangePlusStrand(subChain, &qs, &qe); synGene->chrom = cloneString(subChain->qName); synGene->name = cloneString(gene->name); synGene->txStart = qs; synGene->txEnd = qe; AllocArray(synGene->exonStarts, gene->exonCount); AllocArray(synGene->exonEnds, gene->exonCount); if(chain->qStrand == '+') strncpy(synGene->strand, gene->strand, sizeof(synGene->strand)); else { if(gene->strand[0] == '+') strncpy(synGene->strand, "-", sizeof(synGene->strand)); else if(gene->strand[0] == '-') strncpy(synGene->strand, "+", sizeof(synGene->strand)); else errAbort("Don't recognize strand %s from gene %s", gene->strand, gene->name); } chainFree(&toFree); chainSubSetForRegion(chain, gene->cdsStart, gene->cdsEnd , &subChain, &toFree); if(subChain == NULL ) { if(optionExists("cdsErrorFile")) { cdsErrorFp = fopen( optionVal("cdsErrorFile",NULL), "a" ); fprintf( cdsErrorFp, "%s\t%s\t%u\t%u\t%u\t%u\t%s\t%d\n", gene->name, gene->chrom, gene->txStart, gene->txEnd, gene->cdsStart, gene->cdsEnd, gene->strand, gene->exonCount ); fclose(cdsErrorFp); } *pGene = NULL; genePredFree(&synGene); return; } qChainRangePlusStrand(subChain, &qs, &qe); synGene->cdsStart = qs; synGene->cdsEnd = qe; chainFree(&toFree); *pGene = synGene; }
/* Return is an array of integers, last one of value zero to indicate the * end of the array. In case of nothing found in trackDb, return * a NULL pointer indicating no results. * * If the value is 'first' then use the first span value from the table. * Assumes that all values in the table are the same. */ int *wiggleSpanList(struct sqlConnection *conn, struct trackDb *tdb) { char *tdbDefault = cloneString(trackDbSettingOrDefault(tdb, SPANLIST, "NONE")); int *ret = (int *)NULL; if (sameWord("NONE",tdbDefault)) { struct hashEl *hel; /* if not found in trackDb, maybe it is in tdb->settings * (custom tracks keep settings here) */ if ((tdb->settings != (char *)NULL) && (tdb->settingsHash != (struct hash *)NULL)) { if ((hel = hashLookup(tdb->settingsHash, SPANLIST)) != NULL) { freeMem(tdbDefault); tdbDefault = cloneString((char *)hel->val); } } } /* if we still don't have a spanList, or we got "first" for spanList, * make up spanList by choosing the first span we find in the table */ //if (sameWord("NONE",tdbDefault) || sameWord("first",tdbDefault)) else if( sameWord("first",tdbDefault)) { char query[1024]; snprintf(query, sizeof(query), "SELECT span FROM %s limit 1", tdb->table ); char *tmpSpan = sqlQuickString(conn, query); AllocArray(ret,2); ret[0] = sqlUnsigned(tmpSpan); ret[1] = 0; freeMem(tmpSpan); } else { /* If something found, let's parse it */ int i; char *words[MAX_SPAN_COUNT]; int wc; wc = chopCommas(tdbDefault,words); AllocArray(ret,wc+1); /* + 1 for the extra zero */ for ( i = 0; i < wc; ++i ) ret[i] = sqlUnsigned(words[i]); intSort(wc,ret); ret[wc] = 0; /* end of list */ } freeMem(tdbDefault); return(ret); } /* int *wiggleSpanList(struct trackDb *tdb) */
void output_cluster_matrix_long(struct cluster_bed_matrix *cbm, struct slName *labels, boolean keep_bed, char *outputfile, boolean header) /* For handling long-form cluster output */ { FILE *out = mustOpen(outputfile, "w"); int i, j, l; char **labels_array; int *subpos_array; int *cluster_row_array; int num_labels = slCount(labels); int num_subpos = cbm->pbm->ncol / num_labels; struct slName *label; AllocArray(labels_array, cbm->pbm->ncol); AllocArray(subpos_array, cbm->pbm->ncol); i = 0; for (label = labels; label != NULL; label = label->next) for (j = 0; j < num_subpos; j++) { labels_array[i] = label->name; subpos_array[i] = j+1; i++; } AllocArray(cluster_row_array, cbm->pbm->nrow - cbm->num_na); i = 0; for (j = 0; j < cbm->k; j++) for (l = 0; l < cbm->cluster_sizes[j]; l++) cluster_row_array[i++] = l+1; if (header) { if (keep_bed) fprintf(out, "chrom\tchromStart\tchromEnd\tname\tscore\tstrand\t"); fprintf(out, "Row\tCluster_Name\tCluster_Row\tCentroid_Distance\tLabel_Subpos\tLabel\tSubpos\tColumn\tData\n"); } for (i = cbm->num_na; i < cbm->pbm->nrow; i++) { struct perBaseWig *pbw = cbm->pbm->array[i]; for (j = 0; j < cbm->pbm->ncol; j++) { if (keep_bed) fprintf(out, "%s\t%d\t%d\t%s\t%d\t%c\t", pbw->chrom, pbw->chromStart, pbw->chromEnd, pbw->name, pbw->score, pbw->strand[0]); fprintf(out, "%d\t", i - cbm->num_na + 1); fprintf(out, "Cluster_%d\t", pbw->label + 1); fprintf(out, "%d\t", cluster_row_array[i-cbm->num_na]); fprintf(out, "%f\t", pbw->cent_distance); fprintf(out, "%s_%d\t%s\t%d\t", labels_array[j], subpos_array[j], labels_array[j], subpos_array[j]); fprintf(out, "%d\t", j+1); fprintf(out, "%f\n", cbm->pbm->matrix[i][j]); } } freeMem(labels_array); freeMem(subpos_array); carefulClose(&out); }
struct dMatrix *dataFromTable(char *tableName, char *query) /* Read data from table name with rowname. */ { struct sqlConnection *conn = hAllocConn(); struct slName *colNames = sqlListFields(conn, tableName); struct slName *name = NULL; int count = 0; struct dMatrix *dM = NULL; struct sqlResult *sr = NULL; char **row = NULL; int colIx = 0; /* Allocate some initial memory. */ AllocVar(dM); dM->colCount = slCount(colNames) -1; dM->rowCount = 1; AllocArray(dM->matrix, dM->rowCount); AllocArray(dM->rowNames, dM->rowCount); AllocArray(dM->matrix[0], dM->colCount); AllocArray(dM->colNames, dM->colCount); for(name = colNames->next; name != NULL; name = name->next) dM->colNames[count++] = cloneString(name->name); /* Execute our query. */ sr = sqlGetResult(conn, query); count = 0; /* Read out the data. */ while((row = sqlNextRow(sr)) != NULL) { /* Expand matrix data as necessary. */ if(count > 0) { ExpandArray(dM->matrix, dM->rowCount, dM->rowCount+1); AllocArray(dM->matrix[dM->rowCount], dM->colCount); ExpandArray(dM->rowNames, dM->rowCount, dM->rowCount+1); dM->rowCount++; } dM->rowNames[count] = cloneString(row[0]); for(colIx = 0; colIx < dM->colCount; colIx++) dM->matrix[count][colIx] = atof(row[colIx+1]); count++; } if(count == 0) errAbort("Didn't find any results for query:\n%s", query); sqlFreeResult(&sr); hFreeConn(&conn); return dM; }
void initPcm(struct ggcInfo *g, struct pcm *pcm, char *name, int pixels, bool detailed) /* Allocate and initialize pcm */ { ZeroVar(pcm); pcm->name = cloneString(name); pcm->pixels = pixels; pcm->detailed = detailed; AllocArray(pcm->match, pixels); AllocArray(pcm->cover, pixels); AllocArray(pcm->coverNondash, pixels); AllocArray(pcm->count, pixels); if (g != NULL) slAddTail(&g->pcmList, pcm); }
struct splice *spliceCommaIn(char **pS, struct splice *ret) /* Create a splice out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new splice */ { char *s = *pS; int i; if (ret == NULL) AllocVar(ret); ret->tName = sqlStringComma(&s); ret->tStart = sqlSignedComma(&s); ret->tEnd = sqlSignedComma(&s); ret->name = sqlStringComma(&s); ret->type = sqlSignedComma(&s); sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand)); ret->agxId = sqlSignedComma(&s); ret->vCount = sqlSignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->vPositions, ret->vCount); for (i=0; i<ret->vCount; ++i) { ret->vPositions[i] = sqlSignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); s = sqlEatChar(s, '{'); AllocArray(ret->vTypes, ret->vCount); for (i=0; i<ret->vCount; ++i) { ret->vTypes[i] = sqlUnsignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); ret->pathCount = sqlSignedComma(&s); s = sqlEatChar(s, '{'); for (i=0; i<ret->pathCount; ++i) { s = sqlEatChar(s, '{'); if(s[0] != '}') slSafeAddHead(&ret->paths, pathCommaIn(&s,NULL)); s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); } slReverse(&ret->paths); s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); *pS = s; return ret; }
void hgGenericMicroarray(char *file) /* Load the simple file into two tables.*/ { struct expRecord *exps = NULL; struct expData *data = NULL; struct lineFile *lf = lineFileOpen(file,TRUE); char *strings[1000]; int ncols, i, n; /* First line has experiment info */ ncols = lineFileChopTab(lf,strings); for (i = 1; i < ncols; i++) { struct expRecord *oneRec = NULL; AllocVar(oneRec); oneRec->id = i - 1; oneRec->name = cloneString(strings[i]); oneRec->description = cloneString(strings[i]); oneRec->url = CSNA; oneRec->ref = CSNA; oneRec->credit = CSNA; oneRec->numExtras = 3; AllocArray(oneRec->extras, oneRec->numExtras); oneRec->extras[0] = cloneString("n/a"); oneRec->extras[1] = cloneString("n/a"); oneRec->extras[2] = cloneString(strings[i]); slAddHead(&exps, oneRec); } slReverse(&exps); /* Other lines have the data. */ while ((n = lineFileChopTab(lf,strings)) > 0) { struct expData *oneGene = NULL; AllocVar(oneGene); oneGene->name = cloneString(strings[0]); oneGene->expCount = ncols - 1; AllocArray(oneGene->expScores, oneGene->expCount); for (i = 1; i < ncols; i++) oneGene->expScores[i-1] = sqlFloat(strings[i]); slAddHead(&data, oneGene); } if ((n != ncols) && (n > 0)) errAbort("Wrong number of columns in line %d of %s. Got %d, want %d", lf->lineIx, file, n, ncols); slReverse(&data); saveExpsTable(exps); saveDataTable(data); expRecordFreeList(&exps); expDataFreeList(&data); lineFileClose(&lf); }
struct psl *clonePsl(struct psl *psl) /* Copy a psl to separate memory. */ { struct psl *c = CloneVar(psl); c->next = NULL; c->qName = cloneString(psl->qName); c->tName = cloneString(psl->tName); AllocArray(c->blockSizes, c->blockCount); CopyArray(psl->blockSizes, c->blockSizes, c->blockCount); AllocArray(c->qStarts, c->blockCount); CopyArray(psl->qStarts, c->qStarts, c->blockCount); AllocArray(c->tStarts, c->blockCount); CopyArray(psl->tStarts, c->tStarts, c->blockCount); return c; }
void maxTranscriptomeExps(char *files[], int numFiles, char *outputFile, char *trackName) { struct sample **pSampList = NULL; struct sample *s1; struct sample *maxListSamp = NULL; struct sample *maxSamp = NULL; int i; int count =0; FILE *out = NULL; AllocArray(pSampList, numFiles); for(i=0;i<numFiles; i++) { warn("Reading %s.", files[i]); pSampList[i] = sampleLoadAll(files[i]); } warn("Calculating Maxes."); count = slCount(pSampList[0]); for(i=0;i<count;i++) { AllocVar(maxSamp); s1 = slElementFromIx(pSampList[0], i); maxSamp->chrom = cloneString(s1->chrom); maxSamp->chromStart = s1->chromStart; maxSamp->chromEnd = s1->chromEnd; maxSamp->name = cloneString(trackName); snprintf(maxSamp->strand, sizeof(maxSamp->strand), "%s", s1->strand); maxSamp->sampleCount = s1->sampleCount; maxSamp->samplePosition = CloneArray(s1->samplePosition, maxSamp->sampleCount); AllocArray(maxSamp->sampleHeight, maxSamp->sampleCount); fillInMaxVals(maxSamp, pSampList, numFiles, i); slAddHead(&maxListSamp, maxSamp); } slReverse(&maxListSamp); warn("Saving Maxes"); out = mustOpen(outputFile, "w"); for(maxSamp = maxListSamp; maxSamp != NULL; maxSamp = maxSamp->next) { sampleTabOut(maxSamp, out); } carefulClose(&out); warn("Cleaning up"); sampleFreeList(&maxListSamp); for(i=0;i<numFiles; i++) sampleFreeList(&pSampList[i]); freez(&pSampList); warn("Done."); }
struct starTableInfo *starTableInfoNew(struct sqlConnection *conn, char *name) /* Create new starTable, reading information about it from database. */ { struct starTableInfo *sti; AllocVar(sti); char buf[256]; safef(buf, sizeof(buf), "%s%s", tablePrefix, name); sti->tableName = cloneString(buf); sti->fieldName = cloneString(name); char query[256]; sqlSafef(query, sizeof(query), "select max(id) from %s", sti->tableName); sti->maxId = sqlQuickNum(conn, query); verbose(2, "%s maxId %d\n", sti->tableName, sti->maxId); AllocArray(sti->termsForIds, sti->maxId+1); sqlSafef(query, sizeof(query), "select id,term from %s", sti->tableName); struct sqlResult *sr = sqlGetResult(conn, query); char **row; while ((row = sqlNextRow(sr)) != NULL) { unsigned id = sqlUnsigned(row[0]); char *term = row[1]; sti->termsForIds[id] = cloneString(term); } sqlFreeResult(&sr); return sti; }
void sqlStringDynamicArray(char *s, char ***retArray, int *retSize) /* Convert comma separated list of strings to an dynamically allocated * array, which should be freeMem()'d when done. As a speed option all * of the elements in the array are needMem()'d at the same time. This * means that all the entries are free()'d by calling freeMem() on the * first element. For example: * sqlStringDynamicArray(s, &retArray, &retSize); * DoSomeFunction(retArray, retSize); * freeMem(retArray[0]); * freeMem(retArray); */ { char **sArray, **dArray = NULL; int size; if (s == NULL) { *retArray = NULL; *retSize = 0; return; } s = cloneString(s); sqlStringStaticArray(s, &sArray, &size); if (size > 0) { AllocArray(dArray,size); CopyArray(sArray, dArray, size); } *retArray = dArray; *retSize = size; }
struct path *pathCommaIn(char **pS, struct path *ret) /* Create a path out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new path */ { char *s = *pS; int i; if (ret == NULL) AllocVar(ret); ret->tName = sqlStringComma(&s); ret->tStart = sqlSignedComma(&s); ret->tEnd = sqlSignedComma(&s); ret->type = sqlSignedComma(&s); ret->maxVCount = sqlSignedComma(&s); ret->vCount = sqlSignedComma(&s); s = sqlEatChar(s, '{'); AllocArray(ret->vertices, ret->vCount); for (i=0; i<ret->vCount; ++i) { ret->vertices[i] = sqlSignedComma(&s); } s = sqlEatChar(s, '}'); s = sqlEatChar(s, ','); ret->upV = sqlSignedComma(&s); ret->downV = sqlSignedComma(&s); ret->bpCount = sqlSignedComma(&s); *pS = s; return ret; }
void sortAndWriteOffsets(bits32 firstIx, bits32 *offsetArray, bits32 *listArray, DNA *allDna, FILE *f) /* Set up and do a qsort on list that starts at firstIx. Write result to file. */ { /* Count up length of list. */ int listSize = 0; bits32 listIx; for (listIx = firstIx; listIx != 0; listIx = listArray[listIx]) ++listSize; /* Get an array to hold all offsets in list, hopefully a small one on stack, * but if need be a big one on heap */ bits32 smallArray[32], *bigArray = NULL, *sortArray; if (listSize <= ArraySize(smallArray)) sortArray = smallArray; else AllocArray(sortArray, listSize); /* Copy list to array for sorting. */ int sortIx; for (sortIx=0, listIx=firstIx; listIx != 0; ++sortIx, listIx=listArray[listIx]) sortArray[sortIx] = offsetArray[listIx]; /* Do the qsort. I hope I got the cmp function right! */ qsort(sortArray, listSize, sizeof(sortArray[0]), cmpAfter16); /* Write out sorted result. */ mustWrite(f, sortArray, listSize * sizeof(bits32)); /* Clean up. */ if (bigArray) freeMem(bigArray); }
//----------------------------------------------------------------------------- EStatus BaseArray::SetLength (INT iLengthIn) { INT iNewAllocSize = iAllocSize; // calculate how much to grow the array. while (iLengthIn > iNewAllocSize) { iNewAllocSize += iAllocInc; }; // if more memory is to be allocated, allocate it, copy over old values, and delete old memory. if (iNewAllocSize > iAllocSize) { VOID * pNewArray = AllocArray (iNewAllocSize); // Note: Ideally you need to detect an allocation failure here and return a failure code. if (pNewArray == NULL) return (EStatus::kFailure); INT iOldAllocSize = iAllocSize; VOID * pOldArray = pArray; pArray = pNewArray; iAllocSize = iNewAllocSize; if (iOldAllocSize > 0) { CopyValues (pOldArray, 0, 0, iOldAllocSize); DeleteArray (&pOldArray); }; }; iLength = iLengthIn; return (EStatus::kSuccess); };
float *getWeights(int count) /* Get weights - all 1.0 by default, or read from file otherwise. */ { float *weights; float total = 0.0; int observed = 0; int i; char *fileName = optionVal("weights", NULL); /* Initialize all to 1.0. */ AllocArray(weights, count); for (i=0; i<count; ++i) weights[i] = 1.0; /* Read from file if it exists. */ if (fileName != NULL) { struct lineFile *lf = lineFileOpen(fileName, TRUE); char *row[2]; while (lineFileRow(lf, row)) { int ix = atoi(row[1]); float val = atof(row[0]); if (ix < 0 || ix > count || val <= 0) errAbort("%s does not seem to be a good weight file on line %d", lf->fileName, lf->lineIx); weights[ix] = val; total += val; ++observed; } lineFileClose(&lf); printf("%d genes, %d weights, %f total wieght\n", count, observed, total); } return weights; }
static bits64 bbiWriteSummaryAndIndexUnc(struct bbiSummary *summaryList, int blockSize, int itemsPerSlot, FILE *f) /* Write out summary and index to summary compressed, returning start position of * summary index. */ { bits32 i, count = slCount(summaryList); struct bbiSummary **summaryArray; AllocArray(summaryArray, count); writeOne(f, count); struct bbiSummary *summary; for (summary = summaryList, i=0; summary != NULL; summary = summary->next, ++i) { summaryArray[i] = summary; summary->fileOffset = ftell(f); writeOne(f, summary->chromId); writeOne(f, summary->start); writeOne(f, summary->end); writeOne(f, summary->validCount); bbiWriteFloat(f, summary->minVal); bbiWriteFloat(f, summary->maxVal); bbiWriteFloat(f, summary->sumData); bbiWriteFloat(f, summary->sumSquares); } bits64 indexOffset = ftell(f); cirTreeFileBulkIndexToOpenFile(summaryArray, sizeof(summaryArray[0]), count, blockSize, itemsPerSlot, NULL, bbiSummaryFetchKey, bbiSummaryFetchOffset, indexOffset, f); freez(&summaryArray); return indexOffset; }