static void SampleSobol(This *t, ccount iregion)
{
SAMPLERDEFS;
Vector(real, avg, NCOMP);
real norm;
number i;
count dim, comp;
for( i = 0; i < n; ++i ) {
t->rng.getrandom(t, x);
for( dim = 0; dim < t->ndim; ++x, ++dim )
*x = b[dim].lower + *x*(b[dim].upper - b[dim].lower);
}
t->nrand += n;
DoSample(t, n, samples->x, f);
FCopy(avg, f);
f += t->ncomp;
for( i = 2; i < n; ++i )
for( comp = 0; comp < t->ncomp; ++comp )
avg[comp] += *f++;
norm = region->vol/samples->neff;
for( comp = 0; comp < t->ncomp; ++comp ) {
res[comp].avg = norm*avg[comp];
res[comp].err = 0;
}
}
static void SampleKorobov(This *t, ccount iregion)
{
SAMPLERDEFS;
real *xlast = x + t->ndim, *flast = f + t->ncomp;
Vector(real, avg, NCOMP);
real norm;
cnumber neff = samples->neff;
number nextra = 0, i;
real dist = 0;
count dim, comp;
for( i = 1; i < n; ++i ) {
number c = i;
for( dim = 0; dim < t->ndim; ++dim ) {
creal dx = abs(2*c - neff)/(real)neff;
*xlast++ = b[dim].lower + dx*(b[dim].upper - b[dim].lower);
c = c*samples->coeff % neff;
}
}
for( dim = 0; dim < t->ndim; ++dim ) {
creal dx = (x[dim] = b[dim].upper) - t->border.upper;
if( dx > 0 ) dist += Sq(dx);
}
if( dist > 0 ) {
dist = sqrt(dist)/EXTRAPOLATE_EPS;
for( dim = 0; dim < t->ndim; ++dim ) {
real x2 = x[dim], dx = x2 - t->border.upper;
if( dx > 0 ) {
x[dim] = t->border.upper;
x2 = t->border.upper - dx/dist;
}
xlast[dim] = x2;
}
nextra = 1;
}
DoSample(t, n + nextra, x, f);
FCopy(avg, flast);
flast += t->ncomp;
for( i = 2; i < n; ++i )
for( comp = 0; comp < t->ncomp; ++comp )
avg[comp] += *flast++;
if( nextra ) {
for( comp = 0; comp < t->ncomp; ++comp )
f[comp] += dist*(f[comp] - flast[comp]);
for( dim = 0; dim < t->ndim; ++dim )
x[dim] = b[dim].upper;
}
norm = region->vol/samples->neff;
for( comp = 0; comp < t->ncomp; ++comp ) {
res[comp].avg = norm*(avg[comp] + avg[comp] + f[comp]);
res[comp].err = 0;
}
}
/* Function: P7PriorifyHMM()
*
* Purpose: Add pseudocounts to an HMM using Dirichlet priors,
* and renormalize the HMM.
*
* Args: hmm -- the HMM to add counts to (counts form)
* pri -- the Dirichlet prior to use
*
* Return: (void)
* HMM returns in probability form.
*/
void
P7PriorifyHMM(struct plan7_s *hmm, struct p7prior_s *pri)
{
int k; /* counter for model position */
float d; /* a denominator */
float tq[MAXDCHLET]; /* prior distribution over mixtures */
float mq[MAXDCHLET]; /* prior distribution over mixtures */
float iq[MAXDCHLET]; /* prior distribution over mixtures */
/* Model-dependent transitions are handled simply; Laplace.
*/
FSet(hmm->begin+2, hmm->M-1, 0.); /* wipe internal BM entries */
FSet(hmm->end+1, hmm->M-1, 0.); /* wipe internal ME exits */
d = hmm->tbd1 + hmm->begin[1] + 2.;
hmm->tbd1 = (hmm->tbd1 + 1.)/ d;
hmm->begin[1] = (hmm->begin[1] + 1.)/ d;
hmm->end[hmm->M] = 1.0;
/* Main model transitions and emissions
*/
for (k = 1; k < hmm->M; k++)
{
/* The following code chunk is experimental.
* Collaboration with Michael Asman, Erik Sonnhammer, CGR Stockholm.
* Only activated if X-PR* annotation has been used, in which
* priors are overridden and a single Dirichlet component is
* specified for each column (using structural annotation).
* If X-PR* annotation is not used, which is usually the case,
* the following code has no effect (observe how the real prior
* distributions are copied into tq, mq, iq).
*/
if (hmm->tpri != NULL && hmm->tpri[k] >= 0)
{
if (hmm->tpri[k] >= pri->tnum) Die("X-PRT annotation out of range");
FSet(tq, pri->tnum, 0.0);
tq[hmm->tpri[k]] = 1.0;
}
else
FCopy(tq, pri->tq, pri->tnum);
if (hmm->mpri != NULL && hmm->mpri[k] >= 0)
{
if (hmm->mpri[k] >= pri->mnum) Die("X-PRM annotation out of range");
FSet(mq, pri->mnum, 0.0);
mq[hmm->mpri[k]] = 1.0;
}
else
FCopy(mq, pri->mq, pri->mnum);
if (hmm->ipri != NULL && hmm->ipri[k] >= 0)
{
if (hmm->ipri[k] >= pri->inum) Die("X-PRI annotation out of range");
FSet(iq, pri->inum, 0.0);
iq[hmm->ipri[k]] = 1.0;
}
else
FCopy(iq, pri->iq, pri->inum);
/* This is the main line of the code:
*/
P7PriorifyTransitionVector(hmm->t[k], pri, tq);
P7PriorifyEmissionVector(hmm->mat[k], pri, pri->mnum, mq, pri->m, NULL);
P7PriorifyEmissionVector(hmm->ins[k], pri, pri->inum, iq, pri->i, NULL);
}
/* We repeat the above steps just for the final match state, M.
*/
if (hmm->mpri != NULL && hmm->mpri[hmm->M] >= 0)
{
if (hmm->mpri[hmm->M] >= pri->mnum) Die("X-PRM annotation out of range");
FSet(mq, pri->mnum, 0.0);
mq[hmm->mpri[hmm->M]] = 1.0;
}
else
FCopy(mq, pri->mq, pri->mnum);
P7PriorifyEmissionVector(hmm->mat[hmm->M], pri, pri->mnum, mq, pri->m, NULL);
/* Now we're done. Convert the counts-based HMM to probabilities.
*/
Plan7Renormalize(hmm);
}
/* Function: EmitSequence()
* Date: SRE, Sun Mar 8 12:28:03 1998 [St. Louis]
*
* Purpose: Given a model, sample a sequence and/or traceback.
*
* Args: hmm - the model
* ret_dsq - RETURN: generated digitized sequence (pass NULL if unwanted)
* ret_L - RETURN: length of generated sequence
* ret_tr - RETURN: generated trace (pass NULL if unwanted)
*
* Returns: void
*/
void
EmitSequence(struct plan7_s *hmm, char **ret_dsq, int *ret_L, struct p7trace_s **ret_tr)
{
struct p7trace_s *tr;
enum p7stype type; /* current state type */
int k; /* current node index */
char *dsq; /* generated sequence, digitized */
int L; /* length of sequence */
int alloc_tlen; /* allocated space for traceback */
int alloc_L; /* allocated space for sequence */
int tpos; /* position in traceback */
int sym; /* a generated symbol index */
float t[4]; /* little array for choosing M transition from */
/* Initialize; allocations
*/
P7AllocTrace(64, &tr);
alloc_tlen = 64;
dsq = MallocOrDie(sizeof(char) * 64);
alloc_L = 64;
TraceSet(tr, 0, STS, 0, 0);
TraceSet(tr, 1, STN, 0, 0);
dsq[0] = (char) Alphabet_iupac;
L = 1;
k = 0;
type = STN;
tpos = 2;
while (type != STT)
{
/* Deal with state transition
*/
switch (type) {
case STB: type = STM; k = FChoose(hmm->begin+1, hmm->M) + 1; break;
case STI: type = (FChoose(hmm->t[k]+TIM, 2) == 0) ? STM : STI; if (type == STM) k++; break;
case STN: type = (FChoose(hmm->xt[XTN], 2) == LOOP) ? STN : STB; k = 0; break;
case STE: type = (FChoose(hmm->xt[XTE], 2) == LOOP) ? STJ : STC; k = 0; break;
case STC: type = (FChoose(hmm->xt[XTC], 2) == LOOP) ? STC : STT; k = 0; break;
case STJ: type = (FChoose(hmm->xt[XTJ], 2) == LOOP) ? STJ : STB; k = 0; break;
case STD:
if (k < hmm->M) {
type = (FChoose(hmm->t[k]+TDM, 2) == 0) ? STM : STD;
k++;
} else {
type = STE;
k = 0;
}
break;
case STM:
if (k < hmm->M) {
FCopy(t, hmm->t[k], 3);
t[3] = hmm->end[k];
switch (FChoose(t,4)) {
case 0: k++; type = STM; break;
case 1: type = STI; break;
case 2: k++; type = STD; break;
case 3: k=0; type = STE; break;
default: Die("never happens");
}
} else {
k = 0;
type = STE;
}
break;
case STT:
case STBOGUS:
default:
Die("can't happen.");
}
/* Choose a symbol emission, if necessary
*/
sym = -1;
if (type == STM) sym = FChoose(hmm->mat[k], Alphabet_size);
else if (type == STI) sym = FChoose(hmm->ins[k], Alphabet_size);
else if ((type == STN && tr->statetype[tpos-1] == STN) ||
(type == STC && tr->statetype[tpos-1] == STC) ||
(type == STJ && tr->statetype[tpos-1] == STJ))
sym = FChoose(hmm->null, Alphabet_size);
/* Add to the traceback; deal with realloc if necessary
*/
TraceSet(tr, tpos, type, k, (sym != -1) ? L : 0);
tpos++;
if (tpos == alloc_tlen) {
alloc_tlen += 64;
P7ReallocTrace(tr, alloc_tlen);
}
/* Add to the digitized seq; deal with realloc, if necessary
*/
if (sym != -1) {
dsq[L] = (char) sym;
L++;
if (L+1 == alloc_L) { /* L+1 leaves room for sentinel byte + \0 */
alloc_L += 64;
dsq = ReallocOrDie(dsq, sizeof(char) * alloc_L);
}
}
}
/* Finish off the trace
*/
tr->tlen = tpos;
/* Finish off the dsq with sentinel byte and null terminator.
* Emitted Sequence length is L-1.
*/
dsq[L] = (char) Alphabet_iupac;
dsq[L+1] = '\0';
L--;
/* Return
*/
if (ret_dsq != NULL) *ret_dsq = dsq; else free(dsq);
if (ret_L != NULL) *ret_L = L;
if (ret_tr != NULL) *ret_tr = tr; else P7FreeTrace(tr);
return;
}
static int Integrate(This *t, real *integral, real *error, real *prob)
{
TYPEDEFREGION;
typedef struct pool {
struct pool *next;
Region region[POOLSIZE];
} Pool;
count dim, comp, ncur, ipool, npool;
int fail;
Totals totals[NCOMP];
Pool *cur = NULL, *pool;
Region *region;
if( VERBOSE > 1 ) {
char s[256];
sprintf(s, "Cuhre input parameters:\n"
" ndim " COUNT "\n ncomp " COUNT "\n"
" epsrel " REAL "\n epsabs " REAL "\n"
" flags %d\n mineval " NUMBER "\n maxeval " NUMBER "\n"
" key " COUNT,
t->ndim, t->ncomp,
t->epsrel, t->epsabs,
t->flags, t->mineval, t->maxeval,
t->key);
Print(s);
}
if( BadComponent(t) ) return -2;
if( BadDimension(t) ) return -1;
t->epsabs = Max(t->epsabs, NOTZERO);
RuleAlloc(t);
t->mineval = IMax(t->mineval, t->rule.n + 1);
FrameAlloc(t, ShmRm(t));
ForkCores(t);
if( (fail = setjmp(t->abort)) ) goto abort;
Alloc(cur, 1);
cur->next = NULL;
ncur = 1;
region = cur->region;
region->div = 0;
for( dim = 0; dim < t->ndim; ++dim ) {
Bounds *b = ®ion->bounds[dim];
b->lower = 0;
b->upper = 1;
}
Sample(t, region);
for( comp = 0; comp < t->ncomp; ++comp ) {
Totals *tot = &totals[comp];
Result *r = ®ion->result[comp];
tot->avg = tot->lastavg = tot->guess = r->avg;
tot->err = tot->lasterr = r->err;
tot->weightsum = 1/Max(Sq(r->err), NOTZERO);
tot->avgsum = tot->weightsum*r->avg;
tot->chisq = tot->chisqsum = tot->chisum = 0;
}
for( t->nregions = 1; ; ++t->nregions ) {
count maxcomp, bisectdim;
real maxratio, maxerr;
Result result[NCOMP];
Region *regionL, *regionR;
Bounds *bL, *bR;
if( VERBOSE ) {
char s[128 + 128*NCOMP], *p = s;
p += sprintf(p, "\n"
"Iteration " COUNT ": " NUMBER " integrand evaluations so far",
t->nregions, t->neval);
for( comp = 0; comp < t->ncomp; ++comp ) {
cTotals *tot = &totals[comp];
p += sprintf(p, "\n[" COUNT "] "
REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)",
comp + 1, tot->avg, tot->err, tot->chisq, t->nregions - 1);
}
Print(s);
}
maxratio = -INFTY;
maxcomp = 0;
for( comp = 0; comp < t->ncomp; ++comp ) {
creal ratio = totals[comp].err/MaxErr(totals[comp].avg);
if( ratio > maxratio ) {
maxratio = ratio;
maxcomp = comp;
}
}
if( maxratio <= 1 && t->neval >= t->mineval ) break;
if( t->neval >= t->maxeval ) {
fail = 1;
break;
}
maxerr = -INFTY;
regionL = cur->region;
npool = ncur;
for( pool = cur; pool; npool = POOLSIZE, pool = pool->next )
for( ipool = 0; ipool < npool; ++ipool ) {
Region *region = &pool->region[ipool];
creal err = region->result[maxcomp].err;
if( err > maxerr ) {
maxerr = err;
regionL = region;
}
}
if( ncur == POOLSIZE ) {
Pool *prev = cur;
Alloc(cur, 1);
cur->next = prev;
ncur = 0;
}
regionR = &cur->region[ncur++];
regionR->div = ++regionL->div;
FCopy(result, regionL->result);
XCopy(regionR->bounds, regionL->bounds);
bisectdim = result[maxcomp].bisectdim;
bL = ®ionL->bounds[bisectdim];
bR = ®ionR->bounds[bisectdim];
bL->upper = bR->lower = .5*(bL->upper + bL->lower);
Sample(t, regionL);
Sample(t, regionR);
for( comp = 0; comp < t->ncomp; ++comp ) {
cResult *r = &result[comp];
Result *rL = ®ionL->result[comp];
Result *rR = ®ionR->result[comp];
Totals *tot = &totals[comp];
real diff, err, w, avg, sigsq;
tot->lastavg += diff = rL->avg + rR->avg - r->avg;
diff = fabs(.25*diff);
err = rL->err + rR->err;
if( err > 0 ) {
creal c = 1 + 2*diff/err;
rL->err *= c;
rR->err *= c;
}
rL->err += diff;
rR->err += diff;
tot->lasterr += rL->err + rR->err - r->err;
tot->weightsum += w = 1/Max(Sq(tot->lasterr), NOTZERO);
sigsq = 1/tot->weightsum;
tot->avgsum += w*tot->lastavg;
avg = sigsq*tot->avgsum;
tot->chisum += w *= tot->lastavg - tot->guess;
tot->chisqsum += w*tot->lastavg;
tot->chisq = tot->chisqsum - avg*tot->chisum;
if( LAST ) {
tot->avg = tot->lastavg;
tot->err = tot->lasterr;
}
else {
tot->avg = avg;
tot->err = sqrt(sigsq);
}
}
}
for( comp = 0; comp < t->ncomp; ++comp ) {
cTotals *tot = &totals[comp];
integral[comp] = tot->avg;
error[comp] = tot->err;
prob[comp] = ChiSquare(tot->chisq, t->nregions - 1);
}
#ifdef MLVERSION
if( REGIONS ) {
MLPutFunction(stdlink, "List", 2);
MLPutFunction(stdlink, "List", t->nregions);
npool = ncur;
for( pool = cur; pool; npool = POOLSIZE, pool = pool->next )
for( ipool = 0; ipool < npool; ++ipool ) {
Region const *region = &pool->region[ipool];
real lower[NDIM], upper[NDIM];
for( dim = 0; dim < t->ndim; ++dim ) {
cBounds *b = ®ion->bounds[dim];
lower[dim] = b->lower;
upper[dim] = b->upper;
}
MLPutFunction(stdlink, "Cuba`Cuhre`region", 3);
MLPutRealList(stdlink, lower, t->ndim);
MLPutRealList(stdlink, upper, t->ndim);
MLPutFunction(stdlink, "List", t->ncomp);
for( comp = 0; comp < t->ncomp; ++comp ) {
cResult *r = ®ion->result[comp];
real res[] = {r->avg, r->err};
MLPutRealList(stdlink, res, Elements(res));
}
}
}
#endif
abort:
while( (pool = cur) ) {
cur = cur->next;
free(pool);
}
WaitCores(t);
FrameFree(t);
RuleFree(t);
return fail;
}
DEMOD_STATUS cnxt_lnb_get_parameters( LNB_SETTINGS *lnb )
{
FCopy ( lnb, &lnb_parameters, sizeof ( LNB_SETTINGS ) );
return DEMOD_SUCCESS;
}