int splicing_gff_isolength(const splicing_gff_t *gff,
splicing_vector_int_t *isolength,
splicing_vector_int_t *isolength_idx) {
size_t idx1;
size_t nogenes=splicing_vector_int_size(&gff->genes);
size_t notrans=splicing_vector_int_size(&gff->transcripts);
int pos=-1, ipos=0;
SPLICING_CHECK(splicing_vector_int_resize(isolength, notrans));
SPLICING_CHECK(splicing_vector_int_resize(isolength_idx, nogenes));
for (idx1=VECTOR(gff->genes)[0]; idx1 < gff->n; idx1++) {
if (VECTOR(gff->type)[idx1] == SPLICING_TYPE_GENE) {
VECTOR(*isolength_idx)[ipos++]=pos+1;
} else if (VECTOR(gff->type)[idx1] == SPLICING_TYPE_MRNA) {
VECTOR(*isolength)[++pos] = 0;
} else if (VECTOR(gff->type)[idx1] == SPLICING_TYPE_EXON) {
VECTOR(*isolength)[pos] +=
(VECTOR(gff->end)[idx1] - VECTOR(gff->start)[idx1] + 1);
}
}
return 0;
}
int splicing_create_gene(const splicing_vector_int_t *exons,
const splicing_vector_int_t *isoforms,
const char *id, const char *seqid,
const char *source, splicing_strand_t strand,
splicing_gff_t *extend) {
size_t i=0;
size_t exlen=splicing_vector_int_size(exons);
size_t isolen=splicing_vector_int_size(isoforms);
size_t genestart=splicing_vector_int_min(exons);
size_t geneend=splicing_vector_int_max(exons);
char buffer[5000], buffer2[5000];
int noiso=0;
/* TODO: error checks */
/* Gene */
SPLICING_CHECK(splicing_gff_append(extend, seqid, source,
SPLICING_TYPE_GENE,
genestart, geneend,
/*score=*/ SPLICING_NA_REAL,
strand, /*phase=*/ SPLICING_NA_INTEGER,
id, /*parent=*/ 0));
while (i<isolen) {
size_t mmin=VECTOR(*exons)[ 2*VECTOR(*isoforms)[i] ];
size_t mmax=VECTOR(*exons)[ 2*VECTOR(*isoforms)[i] + 1 ];
size_t j, exon=0;
for (j=i+1; VECTOR(*isoforms)[j] >= 0; j++) {
size_t m1=VECTOR(*exons)[ 2*VECTOR(*isoforms)[j] ];
size_t m2=VECTOR(*exons)[ 2*VECTOR(*isoforms)[j] + 1 ];
if (m1 < mmin) { mmin = m1; }
if (m2 > mmax) { mmax = m2; }
}
snprintf(buffer, sizeof(buffer)/sizeof(char)-sizeof(char),
"%s-isoform-%i", id, noiso);
SPLICING_CHECK(splicing_gff_append(extend, seqid, source,
SPLICING_TYPE_MRNA, mmin, mmax,
/*score=*/ SPLICING_NA_REAL, strand,
/*phase=*/ SPLICING_NA_INTEGER,
buffer, /*parent=*/ id));
for (; VECTOR(*isoforms)[i] >= 0; i++) {
snprintf(buffer2, sizeof(buffer2)/sizeof(char)-sizeof(char),
"%s-isoform-%i-exon-%i", id, (int) noiso, (int) exon++);
SPLICING_CHECK(splicing_gff_append(extend, seqid, source,
SPLICING_TYPE_EXON,
VECTOR(*exons)[ 2*VECTOR(*isoforms)[i] ],
VECTOR(*exons)[ 2*VECTOR(*isoforms)[i] + 1 ],
/*score=*/ SPLICING_NA_REAL, strand,
/*phase=*/ SPLICING_NA_INTEGER, buffer2,
/*parent=*/ buffer));
}
noiso++;
i++;
}
return 0;
}
int splicing_score_joint(const splicing_vector_int_t *assignment,
int no_reads, const splicing_vector_t *psi,
const splicing_vector_t *hyper,
const splicing_vector_int_t *effisolen,
const splicing_vector_t *isoscores,
double *score) {
int i, noiso = splicing_vector_int_size(effisolen);
double readProb = 0.0, assProb, psiProb;
/* Scores the reads */
for (i=0; i<no_reads; i++) {
if (VECTOR(*assignment)[i] != -1) {
readProb += VECTOR(*isoscores)[ VECTOR(*assignment)[i] ];
}
}
/* Score isoforms */
SPLICING_CHECK(splicing_score_iso(psi, noiso, assignment, no_reads,
effisolen, &assProb));
SPLICING_CHECK(splicing_ldirichlet(psi, hyper, noiso, &psiProb));
*score = readProb + assProb + psiProb;
return 0;
}
PyObject *pysplicing_from_vector_int_index(const splicing_vector_int_t *v,
const splicing_vector_int_t *idx) {
int i, n=splicing_vector_int_size(idx);
int vn=splicing_vector_int_size(v);
PyObject *o=PyList_New(n);
for (i=0; i<n; i++) {
int j=VECTOR(*idx)[i];
int x, k= i<n-1 ? VECTOR(*idx)[i+1] : vn;
PyObject *lo=PyList_New(k-j);
for (x=0; j<k; j++, x++) {
PyObject *it=PyInt_FromLong(VECTOR(*v)[j]);
PyList_SetItem(lo, x, it);
}
PyList_SetItem(o, i, lo);
}
return o;
}
PyObject *pysplicing_from_vector_int(const splicing_vector_int_t *v) {
int i, n=splicing_vector_int_size(v);
PyObject *o=PyTuple_New(n);
for (i=0; i<n; i++) {
PyObject *it=PyInt_FromLong(VECTOR(*v)[i]);
PyTuple_SetItem(o, i, it);
}
return o;
}
int splicing_genomic_to_iso(const splicing_gff_t *gff, size_t gene,
const splicing_vector_int_t *position,
splicing_matrix_int_t *isopos) {
size_t r, i, noiso, noreads=splicing_vector_int_size(position);
splicing_vector_int_t exstart, exend, exidx, shift;
splicing_gff_noiso_one(gff, gene, &noiso);
SPLICING_CHECK(splicing_vector_int_init(&exstart, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &exstart);
SPLICING_CHECK(splicing_vector_int_init(&exend, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &exend);
SPLICING_CHECK(splicing_vector_int_init(&exidx, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &exidx);
SPLICING_CHECK(splicing_gff_exon_start_end(gff, &exstart, &exend,
&exidx, gene));
SPLICING_CHECK(splicing_vector_int_init(&shift, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &shift);
for (i=0; i<noiso; i++) {
size_t cs=0, ce=0, ex=0;
int pos=VECTOR(exidx)[i], pos2=VECTOR(exidx)[i+1];
while (pos < pos2) {
cs += VECTOR(exstart)[pos];
SPLICING_CHECK(splicing_vector_int_push_back(&shift, cs-ce-ex-1));
ex++; ce += VECTOR(exend)[pos]; pos++;
}
}
SPLICING_CHECK(splicing_matrix_int_resize(isopos, noiso, noreads));
for (r=0; r<noreads; r++) {
for (i=0; i<noiso; i++) {
size_t pos=VECTOR(*position)[r];
size_t startpos=VECTOR(exidx)[i];
size_t endpos=VECTOR(exidx)[i+1];
int ex;
for (ex=startpos; ex < endpos && VECTOR(exend)[ex] < pos; ex++) ;
if (VECTOR(exstart)[ex] <= pos && pos <= VECTOR(exend)[ex]) {
MATRIX(*isopos, i, r) = VECTOR(*position)[r] - VECTOR(shift)[ex];
} else {
MATRIX(*isopos, i, r) = -1;
}
}
}
splicing_vector_int_destroy(&shift);
splicing_vector_int_destroy(&exidx);
splicing_vector_int_destroy(&exend);
splicing_vector_int_destroy(&exstart);
SPLICING_FINALLY_CLEAN(4);
return 0;
}
int splicing_i_gff_constitutive_exons_all(const splicing_gff_t *gff,
splicing_exonset_t *exons,
int min_length) {
size_t g, nogenes;
splicing_vector_int_t events;
SPLICING_CHECK(splicing_gff_nogenes(gff, &nogenes));
SPLICING_CHECK(splicing_exonset_init(exons, 0));
SPLICING_FINALLY(splicing_exonset_destroy, exons);
SPLICING_CHECK(splicing_vector_int_init(&events, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &events);
for (g=0; g<nogenes; g++) {
const char *seqid=
splicing_strvector_get(&gff->seqids, VECTOR(gff->seqid)[g]);
int noex, idx, noEvents, i;
size_t noiso;
int start=VECTOR(gff->genes)[g];
int end= g+1 < nogenes ? VECTOR(gff->genes)[g+1] : gff->n;
splicing_gff_noiso_one(gff, g, &noiso);
/* Collect and sort all events */
splicing_vector_int_clear(&events);
for (idx=start+1; idx<end; idx++) {
if (VECTOR(gff->type)[idx] == SPLICING_TYPE_EXON) {
SPLICING_CHECK(splicing_vector_int_push_back2
(&events, VECTOR(gff->start)[idx],
-VECTOR(gff->end)[idx]));
}
}
noEvents=splicing_vector_int_size(&events);
splicing_qsort(VECTOR(events), noEvents, sizeof(int),
splicing_i_const_cmp);
/* Now go over the sorted events and extract the constitutive exons */
for (noex=0, i=0; i<noEvents; i++) {
int ev=VECTOR(events)[i];
if (ev > 0) { noex++; }
if (ev < 0) {
int prev=VECTOR(events)[i-1];
if (noex == noiso && (-ev)-prev+1 >= min_length) {
/* constitutive exon */
SPLICING_CHECK(splicing_exonset_append(exons, seqid, prev, -ev));
}
noex--;
}
}
}
splicing_vector_int_destroy(&events);
SPLICING_FINALLY_CLEAN(2); /* + exons */
return 0;
}
int splicing_i_gff_constitutive_exons_full(const splicing_gff_t *gff,
splicing_exonset_t *exons,
int min_length) {
size_t g, nogenes;
splicing_vector_int_t events;
SPLICING_CHECK(splicing_gff_nogenes(gff, &nogenes));
SPLICING_CHECK(splicing_exonset_init(exons, 1));
SPLICING_FINALLY(splicing_exonset_destroy, exons);
SPLICING_CHECK(splicing_vector_int_init(&events, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &events);
for (g=0; g<nogenes; g++) {
const char *seqid=
splicing_strvector_get(&gff->seqids, VECTOR(gff->seqid)[g]);
int i, idx, noExons, noSame;
size_t noiso;
int start=VECTOR(gff->genes)[g];
int end= g+1 < nogenes ? VECTOR(gff->genes)[g+1] : gff->n;
splicing_gff_noiso_one(gff, g, &noiso);
/* Collect and sort all events */
splicing_vector_int_clear(&events);
for (idx=start+1; idx<end; idx++) {
if (VECTOR(gff->type)[idx] == SPLICING_TYPE_EXON) {
SPLICING_CHECK(splicing_vector_int_push_back2
(&events, VECTOR(gff->start)[idx],
VECTOR(gff->end)[idx]));
}
}
noExons=splicing_vector_int_size(&events)/2;
splicing_qsort(VECTOR(events), noExons, sizeof(int)*2,
splicing_i_const_cmp2);
/* Now go over them and check how many times each exon appears */
for (noSame=1, i=2; i<noExons*2; i+=2) {
int start=VECTOR(events)[i];
int end=VECTOR(events)[i+1];
if (start == VECTOR(events)[i-2] && VECTOR(events)[i-1] == end) {
noSame++;
} else {
noSame=1;
}
if (noSame == noiso) {
SPLICING_CHECK(splicing_exonset_append(exons, seqid, start, end));
}
}
}
splicing_vector_int_destroy(&events);
SPLICING_FINALLY_CLEAN(2); /* + exons */
return 0;
}
int splicing_gff_gene_start_end_one(const splicing_gff_t *gff, size_t gene,
size_t *start, size_t *end) {
size_t nogenes=splicing_vector_int_size(&gff->genes);
size_t idx;
if (gene < 0 || gene >= nogenes) {
SPLICING_ERROR("Invalid gene id", SPLICING_EINVAL);
}
idx=VECTOR(gff->genes)[gene];
*start=VECTOR(gff->start)[idx];
*end=VECTOR(gff->end)[idx];
return 0;
}
int splicing_gff_gene_start_end(const splicing_gff_t *gff,
splicing_vector_int_t *start,
splicing_vector_int_t *end) {
size_t i, nogenes=splicing_vector_int_size(&gff->genes);
SPLICING_CHECK(splicing_vector_int_resize(start, nogenes));
SPLICING_CHECK(splicing_vector_int_resize(end, nogenes));
for (i=0; i<nogenes; i++) {
size_t idx=VECTOR(gff->genes)[i];
VECTOR(*start)[i] = VECTOR(gff->start)[idx];
VECTOR(*end)[i] = VECTOR(gff->end)[idx];
}
return 0;
}
int splicing_genomic_to_iso(const splicing_gff_t *gff, size_t gene,
const splicing_vector_int_t *position,
const splicing_gff_converter_t *converter,
splicing_matrix_int_t *isopos) {
size_t r, i, noreads=splicing_vector_int_size(position);
splicing_gff_converter_t vconverter,
*myconverter = (splicing_gff_converter_t*) converter;
if (!converter) {
myconverter=&vconverter;
SPLICING_CHECK(splicing_gff_converter_init(gff, gene, myconverter));
SPLICING_FINALLY(splicing_gff_converter_destroy, myconverter);
}
SPLICING_CHECK(splicing_matrix_int_resize(isopos, myconverter->noiso,
noreads));
for (r=0; r<noreads; r++) {
for (i=0; i<myconverter->noiso; i++) {
size_t pos=VECTOR(*position)[r];
size_t startpos=VECTOR(myconverter->exidx)[i];
size_t endpos=VECTOR(myconverter->exidx)[i+1];
int ex;
for (ex=startpos;
ex < endpos && VECTOR(myconverter->exend)[ex] < pos;
ex++) ;
if (ex < endpos && VECTOR(myconverter->exstart)[ex] <= pos &&
pos <= VECTOR(myconverter->exend)[ex]) {
MATRIX(*isopos, i, r) = VECTOR(*position)[r] -
VECTOR(myconverter->shift)[ex];
} else {
MATRIX(*isopos, i, r) = -1;
}
}
}
if (!converter) {
splicing_gff_converter_destroy(myconverter);
SPLICING_FINALLY_CLEAN(1);
}
return 0;
}
int splicing_iso_to_genomic(const splicing_gff_t *gff, size_t gene,
const splicing_vector_int_t *isoform,
const splicing_gff_converter_t *converter,
splicing_vector_int_t *position) {
size_t i, n=splicing_vector_int_size(position);
splicing_gff_converter_t vconverter,
*myconverter = (splicing_gff_converter_t*) converter;
if (!converter) {
myconverter=&vconverter;
SPLICING_CHECK(splicing_gff_converter_init(gff, gene, myconverter));
SPLICING_FINALLY(splicing_gff_converter_destroy, myconverter);
}
/* Do the shifting */
for (i=0; i<n; i++) {
int iso=VECTOR(*isoform)[i];
size_t pos=VECTOR(*position)[i];
int ex;
if (pos==-1) { continue; }
for (ex=VECTOR(myconverter->exidx)[iso];
ex < VECTOR(myconverter->exidx)[iso+1] &&
VECTOR(myconverter->exlim)[ex] <= pos;
ex++) ;
if (ex < VECTOR(myconverter->exidx)[iso+1]) {
VECTOR(*position)[i] = pos + VECTOR(myconverter->shift)[ex];
} else {
VECTOR(*position)[i] = -1;
}
}
if (!converter) {
splicing_gff_converter_destroy(myconverter);
SPLICING_FINALLY_CLEAN(1);
}
return 0;
}
int splicing_gff_fprint_gene(const splicing_gff_t *gff,
FILE *outfile, int gene) {
size_t nogenes, noiso;
int i, j;
splicing_vector_int_t start, end, idx;
SPLICING_CHECK(splicing_gff_nogenes(gff, &nogenes));
if (gene < 0 || gene >= nogenes) {
SPLICING_ERROR("Invalid gene ID", SPLICING_EINVAL);
}
SPLICING_CHECK(splicing_vector_int_init(&start, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &start);
SPLICING_CHECK(splicing_vector_int_init(&end, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &end);
SPLICING_CHECK(splicing_vector_int_init(&idx, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &idx);
SPLICING_CHECK(splicing_gff_exon_start_end(gff, &start, &end, &idx, gene));
noiso = splicing_vector_int_size(&idx)-1;
fprintf(outfile, "===\nGene with %i isoforms:\n", (int) noiso);
for (i=0; i<noiso; i++) {
fprintf(outfile, " Isoform %i:\n", i);
for (j=VECTOR(idx)[i]; j<VECTOR(idx)[i+1]; j++) {
fprintf(outfile, " %i-%i\n", VECTOR(start)[j], VECTOR(end)[j]);
}
}
splicing_vector_int_destroy(&idx);
splicing_vector_int_destroy(&end);
splicing_vector_int_destroy(&start);
SPLICING_FINALLY_CLEAN(3);
return 0;
}
int splicing_miso(const splicing_gff_t *gff, size_t gene,
const splicing_vector_int_t *position,
const char **cigarstr, int readLength,
int noIterations, int noBurnIn, int noLag,
const splicing_vector_t *hyperp,
splicing_matrix_t *samples, splicing_vector_t *logLik,
splicing_matrix_t *match_matrix,
splicing_matrix_t *class_templates,
splicing_vector_t *class_counts,
splicing_vector_int_t *assignment,
splicing_miso_rundata_t *rundata) {
double acceptP, cJS, pJS, sigma;
int noReads = splicing_vector_int_size(position);
splicing_vector_int_t *myass=assignment, vass;
size_t noiso;
splicing_vector_t vpsi, vpsiNew, valpha, valphaNew,
*psi=&vpsi, *psiNew=&vpsiNew, *alpha=&valpha, *alphaNew=&valphaNew;
int noSamples = (noIterations - noBurnIn + 1) / noLag;
int i, m, lagCounter=0, noS=0;
splicing_matrix_t *mymatch_matrix=match_matrix, vmatch_matrix;
splicing_vector_int_t match_order;
splicing_vector_int_t effisolen;
splicing_vector_t isoscores;
if ( (class_templates ? 1 : 0) + (class_counts ? 1 : 0) == 1) {
SPLICING_ERROR("Only one of `class_templates' and `class_counts' is "
"given", SPLICING_EINVAL);
}
SPLICING_CHECK(splicing_gff_noiso_one(gff, gene, &noiso));
rundata->noIso=noiso;
rundata->noIters=noIterations;
rundata->noBurnIn=noBurnIn;
rundata->noLag=noLag;
rundata->noAccepted = rundata->noRejected = 0;
if (assignment) {
SPLICING_CHECK(splicing_vector_int_resize(myass, noReads));
splicing_vector_int_null(myass);
} else {
myass=&vass;
SPLICING_CHECK(splicing_vector_int_init(myass, noReads));
SPLICING_FINALLY(splicing_vector_int_destroy, myass);
}
SPLICING_CHECK(splicing_vector_init(&vpsi, noiso));
SPLICING_FINALLY(splicing_vector_destroy, &vpsi);
SPLICING_CHECK(splicing_vector_init(&vpsiNew, noiso));
SPLICING_FINALLY(splicing_vector_destroy, &vpsiNew);
SPLICING_CHECK(splicing_vector_init(&valpha, noiso-1));
SPLICING_FINALLY(splicing_vector_destroy, &valpha);
SPLICING_CHECK(splicing_vector_init(&valphaNew, noiso-1));
SPLICING_FINALLY(splicing_vector_destroy, &valphaNew);
if (match_matrix) {
SPLICING_CHECK(splicing_matrix_resize(match_matrix, noiso, noReads));
} else {
mymatch_matrix=&vmatch_matrix;
SPLICING_CHECK(splicing_matrix_init(mymatch_matrix, noiso, noReads));
SPLICING_FINALLY(splicing_matrix_destroy, mymatch_matrix);
}
SPLICING_CHECK(splicing_vector_int_init(&match_order, noReads));
SPLICING_FINALLY(splicing_vector_int_destroy, &match_order);
SPLICING_CHECK(splicing_matchIso(gff, gene, position, cigarstr,
mymatch_matrix));
SPLICING_CHECK(splicing_order_matches(mymatch_matrix, &match_order));
if (class_templates && class_counts) {
SPLICING_CHECK(splicing_i_miso_classes(mymatch_matrix, &match_order,
class_templates, class_counts,
/*bin_class_templates=*/ 0,
/*bin_class_counts=*/ 0));
}
SPLICING_CHECK(splicing_vector_int_init(&effisolen, noiso));
SPLICING_FINALLY(splicing_vector_int_destroy, &effisolen);
SPLICING_CHECK(splicing_vector_init(&isoscores, noiso));
SPLICING_FINALLY(splicing_vector_destroy, &isoscores);
SPLICING_CHECK(splicing_gff_isolength_one(gff, gene, &effisolen));
for (i=0; i<noiso; i++) {
int l=VECTOR(effisolen)[i]-readLength+1;
VECTOR(effisolen)[i] = l > 0 ? l : 0;
VECTOR(isoscores)[i] = -log((double) l);
}
SPLICING_CHECK(splicing_matrix_resize(samples, noiso, noSamples));
SPLICING_CHECK(splicing_vector_resize(logLik, noSamples));
/* Initialize Psi(0) randomly */
SPLICING_CHECK(splicing_drift_proposal(/* mode= */ 0, 0, 0, 0, 0, 0,
noiso, psi, alpha, &sigma, 0));
SPLICING_CHECK(splicing_drift_proposal(/* mode= */ 1, psi, alpha, sigma,
0, 0, noiso, psi, alpha, 0, 0));
/* Initialize assignments of reads */
SPLICING_CHECK(splicing_reassign_samples(mymatch_matrix, &match_order, psi,
noiso, myass));
/* foreach Iteration m=1, ..., M do */
for (m=0; m < noIterations; m++) {
SPLICING_CHECK(splicing_drift_proposal(/* mode= */ 1, psi, alpha, sigma,
0, 0, noiso, psiNew, alphaNew, 0,
0));
SPLICING_CHECK(splicing_metropolis_hastings_ratio(myass, noReads, psiNew,
alphaNew, psi, alpha,
sigma, noiso,
&effisolen, hyperp,
&isoscores,
m > 0 ? 1 : 0,
&acceptP, &cJS, &pJS));
if (acceptP >= 1 || RNG_UNIF01() < acceptP) {
splicing_vector_t *tmp;
tmp=psi; psi=psiNew; psiNew=tmp;
tmp=alpha; alpha=alphaNew; alphaNew=tmp;
cJS = pJS;
rundata->noAccepted ++;
} else {
rundata->noRejected ++;
}
if (m >= noBurnIn) {
if (lagCounter == noLag - 1) {
memcpy(&MATRIX(*samples, 0, noS), VECTOR(*psi),
noiso * sizeof(double));
VECTOR(*logLik)[noS] = cJS;
noS++;
lagCounter = 0;
} else {
lagCounter ++;
}
}
SPLICING_CHECK(splicing_reassign_samples(mymatch_matrix, &match_order,
psi, noiso, myass));
} /* for m < noIterations */
splicing_vector_destroy(&isoscores);
splicing_vector_int_destroy(&effisolen);
splicing_vector_int_destroy(&match_order);
SPLICING_FINALLY_CLEAN(3);
if (!match_matrix) {
splicing_matrix_destroy(mymatch_matrix);
SPLICING_FINALLY_CLEAN(1);
}
splicing_vector_destroy(&valphaNew);
splicing_vector_destroy(&valpha);
splicing_vector_destroy(&vpsiNew);
splicing_vector_destroy(&vpsi);
SPLICING_FINALLY_CLEAN(4);
if (!assignment) {
splicing_vector_int_destroy(myass);
SPLICING_FINALLY_CLEAN(1);
}
return 0;
}
int splicing_iso_to_genomic(const splicing_gff_t *gff, size_t gene,
const splicing_vector_int_t *isoform,
const splicing_vector_int_t *exstart,
const splicing_vector_int_t *exend,
const splicing_vector_int_t *exidx,
splicing_vector_int_t *position) {
size_t i, noiso, n=splicing_vector_int_size(position);
splicing_vector_int_t exlim, shift;
splicing_vector_int_t vexstart, vexend, vexidx,
*myexstart=(splicing_vector_int_t *) exstart,
*myexend=(splicing_vector_int_t *) exend,
*myexidx=(splicing_vector_int_t *) exidx;
size_t pos, pos2;
if (!exstart || !exend || !exidx) {
myexstart=&vexstart;
myexend=&vexend;
myexidx=&vexidx;
SPLICING_CHECK(splicing_vector_int_init(myexstart, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, myexstart);
SPLICING_CHECK(splicing_vector_int_init(myexend, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, myexend);
SPLICING_CHECK(splicing_vector_int_init(myexidx, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, myexidx);
SPLICING_CHECK(splicing_gff_exon_start_end(gff, myexstart, myexend,
myexidx, gene));
}
SPLICING_CHECK(splicing_gff_noiso_one(gff, gene, &noiso));
SPLICING_CHECK(splicing_vector_int_init(&exlim, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &exlim);
SPLICING_CHECK(splicing_vector_int_init(&shift, 0));
SPLICING_FINALLY(splicing_vector_int_destroy, &shift);
for (i=0; i<noiso; i++) {
size_t cs=0, ce=0, ex=0;
int pos=VECTOR(*myexidx)[i], pos2=VECTOR(*myexidx)[i+1];
while (pos < pos2) {
cs += VECTOR(*myexstart)[pos];
SPLICING_CHECK(splicing_vector_int_push_back(&shift, cs-ce-ex-1));
ex++; ce += VECTOR(*myexend)[pos]; pos++;
}
}
for (i=0; i<noiso; i++) {
size_t cs=0;
int pos=VECTOR(*myexidx)[i], pos2=VECTOR(*myexidx)[i+1];
while (pos < pos2) {
size_t l=VECTOR(*myexend)[pos]-VECTOR(*myexstart)[pos]+1;
cs += l;
SPLICING_CHECK(splicing_vector_int_push_back(&exlim, cs+1));
pos++;
}
}
for (i=0; i<n; i++) {
int iso=VECTOR(*isoform)[i];
size_t pos=VECTOR(*position)[i];
int ex;
for (ex=VECTOR(*myexidx)[iso]; VECTOR(exlim)[ex] <= pos; ex++) ;
VECTOR(*position)[i] = pos + VECTOR(shift)[ex];
}
splicing_vector_int_destroy(&shift);
splicing_vector_int_destroy(&exlim);
SPLICING_FINALLY_CLEAN(2);
if (!exstart || !exend || !exidx) {
splicing_vector_int_destroy(myexidx);
splicing_vector_int_destroy(myexend);
splicing_vector_int_destroy(myexstart);
SPLICING_FINALLY_CLEAN(3);
}
return 0;
}
int splicing_gff_nogenes(const splicing_gff_t *gff, size_t *nogenes) {
*nogenes = splicing_vector_int_size(&gff->genes);
return 0;
}
