/* Function: p7_sparsemask_SetFromTrace()
* Synopsis: Set a sparse mask to contain cells in given trace, plus random scatter of others.
*
* Purpose: Add every supercell <i,k> in trace <tr> to the sparse mask <sm>.
*
* If <rng> is provided (i.e. non-<NULL>), on rows <i> with
* at least one such cell, and on 20% of empty rows, also
* mark random sparse supercells with 50% probability
* each. This creates a sparse mask in which the path
* defined by <tr> is marked and can be scored by sparse DP
* routines; plus additional random cells, to try to
* exercise possible failure modes.
*
*/
int
p7_sparsemask_SetFromTrace_avx512(P7_SPARSEMASK *sm, ESL_RANDOMNESS *rng, const P7_TRACE *tr)
{
#ifdef HAVE_AVX512
float cellprob = 0.5;
float rowprob = 0.2;
int i,k,z;
int status;
z = tr->N-1;
for (i = sm->L; i >= 1; i--) /* sparsemask api requires building it backwards */
{
while (tr->i[z] != i) z--; /* find trace position that generated this residue. */
if ( (status = p7_sparsemask_StartRow(sm, i)) != eslOK) return status;
/* If this residue was emitted by the model, at least that cell
* must be present; thus the row must be present.
* Tricky: in addition to the actual emitting cell i,k, we may
* also need to add one or more delete cells i,k-1...
*/
if (p7_trace_IsM(tr->st[z]) || p7_trace_IsI(tr->st[z]))
{
while (p7_trace_IsD(tr->st[z+1])) z++;
for (k = sm->M; k > tr->k[z]; k--)
if (rng && esl_random(rng) < cellprob)
if ((status = p7_sparsemask_Add(sm, (k-1)%sm->Q_AVX_512, (k-1)/sm->Q_AVX_512)) != eslOK) return status;
while (p7_trace_IsD(tr->st[z])) {
k = tr->k[z];
if ((status = p7_sparsemask_Add(sm, (k-1)%sm->Q_AVX_512, (k-1)/sm->Q_AVX_512)) != eslOK) return status;
z--;
}
k = tr->k[z];
if ((status = p7_sparsemask_Add(sm, (k-1)%sm->Q_AVX_512, (k-1)/sm->Q_AVX_512)) != eslOK) return status;
for (k = k-1; k >= 1; k--)
if (rng && esl_random(rng) < cellprob)
if ((status = p7_sparsemask_Add(sm, (k-1)%sm->Q_AVX_512, (k-1)/sm->Q_AVX_512)) != eslOK) return status;
}
else
{
if (rng && esl_random(rng) < rowprob)
for (k = sm->M; k >= 1; k--)
if (rng && esl_random(rng) < cellprob)
if ((status = p7_sparsemask_Add(sm, (k-1)%sm->Q_AVX_512, (k-1)/sm->Q_AVX_512)) != eslOK) return status; /* append to k[i] list, increment n[i] count, reallocating as needed; doesn't deal w/ segments (nrow,nseg,i[]) */
}
if ((status = p7_sparsemask_FinishRow(sm)) != eslOK) return status;
}
if ( (status = p7_sparsemask_Finish(sm)) != eslOK) return status;
return eslOK;
#endif
#ifndef HAVE_AVX512
return eslENORESULT;
#endif
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
int N = esl_opt_GetInteger(go, "-N");
P7_TOPHITS *h1 = NULL;
P7_TOPHITS *h2 = NULL;
P7_TOPHITS *h3 = NULL;
char name[] = "not_unique_name";
char acc[] = "not_unique_acc";
char desc[] = "Test description for the purposes of making the test driver allocate space";
double key;
int i;
fprintf(stderr, "## %s\n", argv[0]);
fprintf(stderr, "# rng seed = %" PRIu32 "\n", esl_randomness_GetSeed(r));
h1 = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
h2 = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
h3 = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
for (i = 0; i < N; i++)
{
key = esl_random(r);
tophits_Add(h1, name, acc, desc, key);
key = 10.0 * esl_random(r);
tophits_Add(h2, name, acc, desc, key);
key = 0.1 * esl_random(r);
tophits_Add(h3, name, acc, desc, key);
}
tophits_Add(h1, "last", NULL, NULL, -1.0);
tophits_Add(h1, "first", NULL, NULL, 20.0);
p7_tophits_SortBySortkey(h1);
if (strcmp(h1->hit[0]->name, "first") != 0) esl_fatal("sort failed (top is %s = %f)", h1->hit[0]->name, h1->hit[0]->sortkey);
if (strcmp(h1->hit[N+1]->name, "last") != 0) esl_fatal("sort failed (last is %s = %f)", h1->hit[N+1]->name, h1->hit[N+1]->sortkey);
p7_tophits_Merge(h1, h2);
if (strcmp(h1->hit[0]->name, "first") != 0) esl_fatal("after merge 1, sort failed (top is %s = %f)", h1->hit[0]->name, h1->hit[0]->sortkey);
if (strcmp(h1->hit[2*N+1]->name, "last") != 0) esl_fatal("after merge 1, sort failed (last is %s = %f)", h1->hit[2*N+1]->name, h1->hit[2*N+1]->sortkey);
p7_tophits_Merge(h3, h1);
if (strcmp(h3->hit[0]->name, "first") != 0) esl_fatal("after merge 2, sort failed (top is %s = %f)", h3->hit[0]->name, h3->hit[0]->sortkey);
if (strcmp(h3->hit[3*N+1]->name, "last") != 0) esl_fatal("after merge 2, sort failed (last is %s = %f)", h3->hit[3*N+1]->name, h3->hit[3*N+1]->sortkey);
if (p7_tophits_GetMaxNameLength(h3) != strlen(name)) esl_fatal("GetMaxNameLength() failed");
p7_tophits_Destroy(h1);
p7_tophits_Destroy(h2);
p7_tophits_Destroy(h3);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
fprintf(stderr, "# status = ok\n");
return eslOK;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_STOPWATCH *w = esl_stopwatch_Create();
int N = esl_opt_GetInteger(go, "-N");
int i;
float *A, *B, *C;
p7_FLogsumInit();
/* Create the problem: sample N values A,B on interval -1000,1000: about the range of H3 scores */
A = malloc(sizeof(float) * N);
B = malloc(sizeof(float) * N);
C = malloc(sizeof(float) * N);
for (i = 0; i < N; i++)
{
A[i] = esl_random(r) * 2000. - 1000.;
B[i] = esl_random(r) * 2000. - 1000.;
}
/* Run */
esl_stopwatch_Start(w);
if (esl_opt_GetBoolean(go, "-n"))
{
for (i = 0; i < N; i++)
C[i] = naive2(A[i], B[i]);
}
else if (esl_opt_GetBoolean(go, "-r"))
{
for (i = 0; i < N; i++)
C[i] = naive1(A[i], B[i]);
}
else
{
for (i = 0; i < N; i++)
C[i] = p7_FLogsum(A[i], B[i]);
}
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
/* Using FChoose() here would mean allocating tmp space for 2M-1 paths;
* instead we use the fact that E(i) is itself the necessary normalization
* factor, and implement FChoose's algorithm here for an on-the-fly
* calculation.
* Note that that means double-precision calculation, to be sure 0.0 <= roll < 1.0
*/
static inline int
select_e(ESL_RANDOMNESS *rng, const P7_OPROFILE *om, const P7_OMX *ox, int i, int *ret_k)
{
int Q = p7O_NQF(ox->M);
double sum = 0.0;
double roll = esl_random(rng);
double norm = 1.0 / ox->xmx[i*p7X_NXCELLS+p7X_E];
__m128 xEv = _mm_set1_ps(norm); /* all M, D already scaled exactly the same */
union { __m128 v; float p[4]; } u;
int q,r;
while (1) {
for (q = 0; q < Q; q++)
{
u.v = _mm_mul_ps(ox->dpf[i][q*3 + p7X_M], xEv);
for (r = 0; r < 4; r++) {
sum += u.p[r];
if (roll < sum) { *ret_k = r*Q + q + 1; return p7T_M;}
}
u.v = _mm_mul_ps(ox->dpf[i][q*3 + p7X_D], xEv);
for (r = 0; r < 4; r++) {
sum += u.p[r];
if (roll < sum) { *ret_k = r*Q + q + 1; return p7T_D;}
}
}
ESL_DASSERT1((sum > 0.99));
}
/*UNREACHED*/
ESL_EXCEPTION(-1, "unreached code was reached. universe collapses.");
}
static int
save_bitfile(char *bitfile, ESL_RANDOMNESS *r, int n)
{
FILE *fp = NULL;
int b,i;
long x;
/* Open the file.
*/
if ((fp = fopen(bitfile, "w")) == NULL)
esl_fatal("failed to open %s for writing", bitfile);
/* Sample <n> random numbers, output 31n random bits to the file.
*/
for (i = 0; i < n; i++)
{
esl_random(r);
x = r->rnd; /* peek inside, get the 31 bit random long */
for (b = 0; b < 31; b++) /* don't print the sign bit. */
{
if (x & 01) fprintf(fp, "1");
else fprintf(fp, "0");
x >>= 1;
}
fprintf(fp, "\n");
}
fclose(fp);
return eslOK;
}
/* Function: esl_rnd_UniformPositive()
* Synopsis: Generate a uniform positive random deviate $0 < x < 1$.
* Incept: SRE, Wed Jul 14 13:31:23 2004 [St. Louis]
*
* Purpose: Same as <esl_random()>, but assure $0 < x < 1$;
* (positive uniform deviate).
*/
double
esl_rnd_UniformPositive(ESL_RANDOMNESS *r)
{
double x;
do { x = esl_random(r); } while (x == 0.0);
return x;
}
/* subfunctions that esl_rnd_Gamma() is going to call:
*/
static double
gamma_ahrens(ESL_RANDOMNESS *r, double a) /* for a >= 3 */
{
double V; /* uniform deviates */
double X,Y;
double test;
do {
do { /* generate candidate X */
Y = tan(eslCONST_PI * esl_random(r));
X = Y * sqrt(2.*a -1.) + a - 1.;
} while (X <= 0.);
/* accept/reject X */
V = esl_random(r);
test = (1+Y*Y) * exp( (a-1.)* log(X/(a-1.)) - Y*sqrt(2.*a-1.));
} while (V > test);
return X;
}
/* Function: esl_randomness_Init()
* Synopsis: Reinitialize an RNG.
* Incept: SRE, Wed Jul 14 13:13:05 2004 [St. Louis]
*
* Purpose: Reset and reinitialize an existing <ESL_RANDOMNESS>
* object.
*
* (Not generally recommended. This does not make a
* sequence of numbers more random, and may make it less
* so.)
*
* Args: r - randomness object
* seed - new seed to use; >0.
*
* Returns: <eslOK> on success.
*
* Throws: <eslEINVAL> if seed is $<= 0$.
*
* Xref: STL8/p57.
*/
int
esl_randomness_Init(ESL_RANDOMNESS *r, long seed)
{
int burnin = 7;
if (seed <= 0) ESL_EXCEPTION(eslEINVAL, "bad seed");
r->seed = seed;
while (burnin--) esl_random(r);
return eslOK;
}
static double
gamma_fraction(ESL_RANDOMNESS *r, double a) /* for fractional a, 0 < a < 1 */
{ /* Knuth 3.4.1, exercise 16, pp. 586-587 */
double p, U, V, X, q;
p = eslCONST_E / (a + eslCONST_E);
do {
U = esl_random(r);
V = esl_rnd_UniformPositive(r);
if (U < p) {
X = pow(V, 1./a);
q = exp(-X);
} else {
X = 1. - log(V);
q = pow(X, a-1.);
}
U = esl_random(r);
} while (U >= q);
return X;
}
int
main(void)
{
ESL_RANDOMNESS *r = esl_randomness_Create(42);
int n = 10;
printf("A sequence of %d pseudorandom numbers:\n", n);
while (n--) printf("%f\n", esl_random(r));
esl_randomness_Destroy(r);
return 0;
}
/* Function: esl_mixgev_FitGuess()
*
* Purpose: Make initial randomized guesses at the parameters
* of mixture GEV <mg>, using random number generator
* <r> and observed data consisting of <n> values
* <x[0..n-1]>. This guess is a suitable starting
* point for a parameter optimization routine, such
* as <esl_mixgev_FitComplete()>.
*
* Specifically, we estimate one 'central' guess
* for a single Gumbel fit to the data, using the
* method of moments. Then we add $\pm 10\%$ to that 'central'
* $\mu$ and $\lambda$ to get each component
* $\mu_i$ and $\lambda_i$. The $\alpha_i$ parameters
* are generated by sampling uniformly from $-0.1..0.1$.
* Mixture coefficients $q_i$ are sampled uniformly.
*
* Args: r - randomness source
* x - vector of observed data values to fit, 0..n-1
* n - number of values in <x>
* mg - mixture GEV to put guessed params into
*
* Returns: <eslOK> on success.
*/
int
esl_mixgev_FitGuess(ESL_RANDOMNESS *r, double *x, int n, ESL_MIXGEV *mg)
{
double mean, variance;
double mu, lambda;
int k;
esl_stats_DMean(x, n, &mean, &variance);
lambda = eslCONST_PI / sqrt(6.*variance);
mu = mean - 0.57722/lambda;
esl_dirichlet_DSampleUniform(r, mg->K, mg->q);
for (k = 0; k < mg->K; k++)
{
mg->mu[k] = mu + 0.2 * mu * (esl_random(r) - 0.5);
mg->lambda[k] = lambda + 0.2 * lambda * (esl_random(r) - 0.5);
if (mg->isgumbel[k]) mg->alpha[k] = 0.;
else mg->alpha[k] = 0.2 * (esl_random(r) - 0.5);
}
return eslOK;
}
static void
utest_FLogsumError(ESL_GETOPTS *go, ESL_RANDOMNESS *r)
{
int N = esl_opt_GetInteger(go, "-N");
float maxval = esl_opt_GetReal(go, "-S");
int be_verbose = esl_opt_GetBoolean(go, "-v");
float maxerr = 0.0;
float avgerr = 0.0;
int i;
float a,b,result,exact,err;
for (i = 0; i < N; i++)
{
a = (esl_random(r) - 0.5) * maxval * 2.; /* uniform draws on -maxval..maxval */
b = (esl_random(r) - 0.5) * maxval * 2.;
exact = log(exp(a) + exp(b));
result = p7_FLogsum(a,b);
err = fabs(exact-result) / maxval;
avgerr += err;
maxerr = ESL_MAX(maxerr, err);
if (be_verbose)
printf("%8.4f %8.4f %8.4f %8.4f %8.4f\n", a, b, exact, result, err);
}
avgerr /= (float) N;
if (be_verbose) {
printf("average error = %f\n", avgerr);
printf("max error = %f\n", maxerr);
}
if (maxerr > 0.0001) esl_fatal("maximum error of %f is too high: logsum unit test fails", maxerr);
if (avgerr > 0.0001) esl_fatal("average error of %f is too high: logsum unit test fails", avgerr);
}
/* Function: esl_randomness_CreateTimeseeded()
* Synopsis: Create an RNG with a quasirandom seed.
* Incept: SRE, Wed Jul 14 11:22:54 2004 [St. Louis]
*
* Purpose: Like <esl_randomness_Create()>, but it initializes the
* the random number generator using a POSIX <time()> call
* (number of seconds since the POSIX epoch).
*
* Returns: an initialized <ESL_RANDOMNESS *> on success.
* Caller free's with <esl_randomness_Destroy()>.
*
* Throws: <NULL> on failure.
*
* Xref: STL8/p57.
*/
ESL_RANDOMNESS *
esl_randomness_CreateTimeseeded(void)
{
ESL_RANDOMNESS *r = NULL;
int burnin = 7;
int status;
ESL_ALLOC(r, sizeof(ESL_RANDOMNESS));
r->seed = time ((time_t *) NULL);
r->reseeding = TRUE;
while (burnin--) esl_random(r);
return r;
ERROR:
return NULL;
}
/* Function: p7_hit_TestSample()
* Synopsis: Sample a random, bogus, mostly syntactic P7_HIT.
*
* Purpose: Sample a random but syntactically valid <P7_HIT>
* array, using random number generator <rng>, and
* store it in <hit>, space provided by the caller
* (usually, one <P7_HIT> in an array that the caller
* has).
*/
int
p7_hit_TestSample(ESL_RANDOMNESS *rng, P7_HIT *hit)
{
int d;
int status;
if ((status = esl_rsq_Sample(rng, eslRSQ_SAMPLE_GRAPH, 1+esl_rnd_Roll(rng, 30), &(hit->name))) != eslOK) goto ERROR;
if (esl_rnd_Roll(rng, 2)) { if ((status = esl_rsq_Sample(rng, eslRSQ_SAMPLE_ALNUM, 1+esl_rnd_Roll(rng, 10), &(hit->acc))) != eslOK) goto ERROR; }
if (esl_rnd_Roll(rng, 2)) { if ((status = esl_rsq_Sample(rng, eslRSQ_SAMPLE_PRINT, 1+esl_rnd_Roll(rng, 120), &(hit->desc))) != eslOK) goto ERROR; }
hit->window_length = 1 + esl_rnd_Roll(rng, 100000);
hit->sortkey = -1000. + 2000. * esl_random(rng);
hit->score = -1000. + 2000. * esl_random(rng);
hit->pre_score = -1000. + 2000. * esl_random(rng);
hit->sum_score = -1000. + 2000. * esl_random(rng);
hit->lnP = -1000. + 2000. * esl_random(rng);
hit->pre_lnP = -1000. + 2000. * esl_random(rng);
hit->sum_lnP = -1000. + 2000. * esl_random(rng);
hit->ndom = 1 + esl_rnd_Roll(rng, 10);
hit->noverlaps = esl_rnd_Roll(rng, hit->ndom);
hit->nexpected = esl_random(rng)*10;
hit->flags = p7_HITFLAGS_DEFAULT;
if (esl_rnd_Roll(rng, 2)) hit->flags |= p7_IS_INCLUDED;
if (esl_rnd_Roll(rng, 2)) hit->flags |= p7_IS_REPORTED;
if (esl_rnd_Roll(rng, 2)) hit->flags |= p7_IS_NEW;
if (esl_rnd_Roll(rng, 2)) hit->flags |= p7_IS_DROPPED;
if (esl_rnd_Roll(rng, 2)) hit->flags |= p7_IS_DUPLICATE;
hit->nreported = 1 + esl_rnd_Roll(rng, hit->ndom);
hit->nincluded = 1 + esl_rnd_Roll(rng, hit->ndom);
hit->best_domain = esl_rnd_Roll(rng, hit->ndom);
hit->seqidx = 1 + esl_rnd_Roll(rng, 1000000);
hit->subseq_start = 1 + esl_rnd_Roll(rng, 1000000);
hit->offset = 1 + esl_rnd_Roll(rng, 1000000);
if (( hit->dcl = p7_domain_Create(hit->ndom) ) == NULL) { status = eslEMEM; goto ERROR; }
for (d = 0; d < hit->ndom; d++)
if (( status = p7_domain_TestSample(rng, 1 + esl_rnd_Roll(rng, 100), &(hit->dcl[d]))) != eslOK) goto ERROR;
return eslOK;
ERROR:
/* should free inside hit; caller has the shell of it though */
return status;
}
int
esl_rnd_FChoose(ESL_RANDOMNESS *r, const float *p, int N)
{
float roll; /* random fraction */
float sum; /* integrated prob */
int i; /* counter over the probs */
roll = esl_random(r);
sum = 0.0;
while (1) { /* see note in header about this while() */
for (i = 0; i < N; i++)
{
sum += p[i];
if (roll < sum) return i; /* success */
}
if (sum < 0.99) ESL_EXCEPTION(-1, "unnormalized distribution"); /* avoid inf loop */
}
/*UNREACHED*/
ESL_EXCEPTION(-1, "unreached code was reached. universe collapses.");
}
/* Function: esl_randomness_Create()
* Synopsis: Create an RNG with a given seed.
* Incept: SRE, Wed Jul 14 13:02:18 2004 [St. Louis]
*
* Purpose: Create a random number generator using
* a given random seed. Seed must be $>0$.
*
* Args: seed $>= 0$.
*
* Returns: an initialized <ESL_RANDOMNESS *> on success.
* Caller free's with <esl_randomness_Destroy()>.
*
* Throws: <NULL> on failure.
*
* Xref: STL8/p57.
*/
ESL_RANDOMNESS *
esl_randomness_Create(long seed)
{
ESL_RANDOMNESS *r = NULL;
int burnin = 7;
int status;
if (seed <= 0) ESL_XEXCEPTION(eslEINVAL, "bad seed");
ESL_ALLOC(r, sizeof(ESL_RANDOMNESS));
r->seed = seed;
r->reseeding = TRUE;
/* we observe that the first random number isn't very random, if
* closely spaced seeds are used, like what we get with using
* time(). So, "burn in" the random chain just a little.
*/
while (burnin--) esl_random(r);
return r;
ERROR:
return NULL;
}
/* The LogGamma() function is rate-limiting in hmmbuild, because it is
* used so heavily in mixture Dirichlet calculations.
* ./configure --with-gsl; [compile test driver]
* ./stats_utest -v
* runs a comparison of time/precision against GSL.
* SRE, Sat May 23 10:04:41 2009, on home Mac:
* LogGamma = 1.29u / N=1e8 = 13 nsec/call
* gsl_sf_lngamma = 1.43u / N=1e8 = 14 nsec/call
*/
static void
utest_LogGamma(ESL_RANDOMNESS *r, int N, int be_verbose)
{
char *msg = "esl_stats_LogGamma() unit test failed";
ESL_STOPWATCH *w = esl_stopwatch_Create();
double *x = malloc(sizeof(double) * N);
double *lg = malloc(sizeof(double) * N);
double *lg2 = malloc(sizeof(double) * N);
int i;
for (i = 0; i < N; i++)
x[i] = esl_random(r) * 100.;
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
if (esl_stats_LogGamma(x[i], &(lg[i])) != eslOK) esl_fatal(msg);
esl_stopwatch_Stop(w);
if (be_verbose) esl_stopwatch_Display(stdout, w, "esl_stats_LogGamma() timing: ");
#ifdef HAVE_LIBGSL
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) lg2[i] = gsl_sf_lngamma(x[i]);
esl_stopwatch_Stop(w);
if (be_verbose) esl_stopwatch_Display(stdout, w, "gsl_sf_lngamma() timing: ");
for (i = 0; i < N; i++)
if (esl_DCompare(lg[i], lg2[i], 1e-2) != eslOK) esl_fatal(msg);
#endif
free(lg2);
free(lg);
free(x);
esl_stopwatch_Destroy(w);
}
/* Using FChoose() here would mean allocating tmp space for 2M-1 paths;
* instead we use the fact that E(i) is itself the necessary normalization
* factor, and implement FChoose's algorithm here for an on-the-fly
* calculation.
*/
static inline int
select_e(ESL_RANDOMNESS *rng, const P7_OPROFILE *om, const P7_OMX *ox, int i, int *ret_k)
{
int Q = p7O_NQF(ox->M);
float sum = 0.0;
float roll = esl_random(rng);
float norm = 1.0 / ox->xmx[i*p7X_NXCELLS+p7X_E]; /* all M, D already scaled exactly the same */
vector float xEv;
vector float zerov;
union { vector float v; float p[4]; } u;
int q,r;
xEv = esl_vmx_set_float(norm);
zerov = (vector float) vec_splat_u32(0);
while (1) {
for (q = 0; q < Q; q++)
{
u.v = vec_madd(ox->dpf[i][q*3 + p7X_M], xEv, zerov);
for (r = 0; r < 4; r++) {
sum += u.p[r];
if (roll < sum) { *ret_k = r*Q + q + 1; return p7T_M;}
}
u.v = vec_madd(ox->dpf[i][q*3 + p7X_D], xEv, zerov);
for (r = 0; r < 4; r++) {
sum += u.p[r];
if (roll < sum) { *ret_k = r*Q + q + 1; return p7T_D;}
}
}
if (sum < 0.99)
ESL_EXCEPTION(-1, "Probabilities weren't normalized - failed to trace back from an E");
}
/*UNREACHED*/
ESL_EXCEPTION(-1, "unreached code was reached. universe collapses.");
}
/* Function: esl_rnd_Gaussian()
* Synopsis: Generate a Gaussian-distributed sample.
* Incept: SRE, Wed Jul 14 13:50:36 2004 [St. Louis]
*
* Purpose: Pick a Gaussian-distributed random variable
* with a given <mean> and standard deviation <stddev>, and
* return it.
*
* Implementation is derived from the public domain
* RANLIB.c <gennor()> function, written by Barry W. Brown
* and James Lovato (M.D. Anderson Cancer Center, Texas
* USA) using the method described in
* \citep{AhrensDieter73}.
*
* Method: Impenetrability of the code is to be blamed on
* FORTRAN/f2c lineage.
*
* Args: r - ESL_RANDOMNESS object
* mean - mean of the Gaussian we're sampling from
* stddev - standard deviation of the Gaussian
*/
double
esl_rnd_Gaussian(ESL_RANDOMNESS *r, double mean, double stddev)
{
long i;
double snorm,u,s,ustar,aa,w,y,tt;
/* These static's are threadsafe: they are magic constants
* we will not touch.
*/
static double a[32] = {
0.0,3.917609E-2,7.841241E-2,0.11777,0.1573107,0.1970991,0.2372021,0.2776904,
0.3186394,0.36013,0.4022501,0.4450965,0.4887764,0.5334097,0.5791322,
0.626099,0.6744898,0.7245144,0.7764218,0.8305109,0.8871466,0.9467818,
1.00999,1.077516,1.150349,1.229859,1.318011,1.417797,1.534121,1.67594,
1.862732,2.153875
};
static double d[31] = {
0.0,0.0,0.0,0.0,0.0,0.2636843,0.2425085,0.2255674,0.2116342,0.1999243,
0.1899108,0.1812252,0.1736014,0.1668419,0.1607967,0.1553497,0.1504094,
0.1459026,0.14177,0.1379632,0.1344418,0.1311722,0.128126,0.1252791,
0.1226109,0.1201036,0.1177417,0.1155119,0.1134023,0.1114027,0.1095039
};
static double t[31] = {
7.673828E-4,2.30687E-3,3.860618E-3,5.438454E-3,7.0507E-3,8.708396E-3,
1.042357E-2,1.220953E-2,1.408125E-2,1.605579E-2,1.81529E-2,2.039573E-2,
2.281177E-2,2.543407E-2,2.830296E-2,3.146822E-2,3.499233E-2,3.895483E-2,
4.345878E-2,4.864035E-2,5.468334E-2,6.184222E-2,7.047983E-2,8.113195E-2,
9.462444E-2,0.1123001,0.136498,0.1716886,0.2276241,0.330498,0.5847031
};
static double h[31] = {
3.920617E-2,3.932705E-2,3.951E-2,3.975703E-2,4.007093E-2,4.045533E-2,
4.091481E-2,4.145507E-2,4.208311E-2,4.280748E-2,4.363863E-2,4.458932E-2,
4.567523E-2,4.691571E-2,4.833487E-2,4.996298E-2,5.183859E-2,5.401138E-2,
5.654656E-2,5.95313E-2,6.308489E-2,6.737503E-2,7.264544E-2,7.926471E-2,
8.781922E-2,9.930398E-2,0.11556,0.1404344,0.1836142,0.2790016,0.7010474
};
u = esl_random(r);
s = 0.0;
if(u > 0.5) s = 1.0;
u += (u-s);
u = 32.0*u;
i = (long) (u);
if(i == 32) i = 31;
if(i == 0) goto S100;
/*
* START CENTER
*/
ustar = u-(double)i;
aa = a[i-1];
S40:
if (ustar <= t[i-1]) goto S60;
w = (ustar - t[i-1]) * h[i-1];
S50:
/*
* EXIT (BOTH CASES)
*/
y = aa+w;
snorm = y;
if(s == 1.0) snorm = -y;
return (stddev*snorm + mean);
S60:
/*
* CENTER CONTINUED
*/
u = esl_random(r);
w = u*(a[i]-aa);
tt = (0.5*w+aa)*w;
goto S80;
S70:
tt = u;
ustar = esl_random(r);
S80:
if(ustar > tt) goto S50;
u = esl_random(r);
if(ustar >= u) goto S70;
ustar = esl_random(r);
goto S40;
S100:
/*
* START TAIL
*/
i = 6;
aa = a[31];
goto S120;
S110:
aa += d[i-1];
i += 1;
S120:
u += u;
if(u < 1.0) goto S110;
u -= 1.0;
S140:
w = u*d[i-1];
tt = (0.5*w+aa)*w;
goto S160;
S150:
tt = u;
S160:
ustar = esl_random(r);
if(ustar > tt) goto S50;
u = esl_random(r);
if(ustar >= u) goto S150;
u = esl_random(r);
goto S140;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
int N = esl_opt_GetInteger(go, "-N");
int M = esl_opt_GetInteger(go, "-M");
P7_TOPHITS **h = NULL;
P7_HIT *hit = NULL;
double *sortkeys = NULL;
char name[] = "not_unique_name";
char acc[] = "not_unique_acc";
char desc[] = "Test description for the purposes of making the benchmark allocate space";
int i,j;
int status;
/* prep work: generate our sort keys before starting to time anything */
ESL_ALLOC(h, sizeof(P7_TOPHITS *) * M); /* allocate pointers for M lists */
ESL_ALLOC(sortkeys, sizeof(double) * N * M);
for (i = 0; i < N*M; i++) sortkeys[i] = esl_random(r);
esl_stopwatch_Start(w);
/* generate M "random" lists and sort them */
for (j = 0; j < M; j++)
{
h[j] = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
for (i = 0; i < N; i++)
{
p7_tophits_CreateNextHit(h[j], &hit);
esl_strdup(name, -1, &(hit->name));
esl_strdup(acc, -1, &(hit->acc));
esl_strdup(desc, -1, &(hit->desc));
hit->sortkey = sortkeys[j*N + i];
hit->score = (float) sortkeys[j*N+i];
hit->pre_score = 0.0;
hit->sum_score = 0.0;
hit->lnP = sortkeys[j*N+i];
hit->pre_lnP = 0.0;
hit->sum_lnP = 0.0;
hit->ndom = N;
hit->noverlaps = 0;
hit->nexpected = 0;
hit->flags = 0;
hit->nreported = 0;
hit->nincluded = 0;
hit->best_domain = 0;
hit->dcl = NULL;
}
p7_tophits_SortBySortkey(h[j]);
}
/* then merge them into one big list in h[0] */
for (j = 1; j < M; j++)
{
p7_tophits_Merge(h[0], h[j]);
p7_tophits_Destroy(h[j]);
}
esl_stopwatch_Stop(w);
p7_tophits_Destroy(h[0]);
status = eslOK;
ERROR:
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
if (sortkeys != NULL) free(sortkeys);
if (h != NULL) free(h);
return status;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
int N = esl_opt_GetInteger(go, "-N");
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_TRACE *tr = NULL;
ESL_SQ *sq = NULL;
P7_ALIDISPLAY *ad = NULL;
int i,z;
if (p7_hmmfile_Open(hmmfile, NULL, &hfp) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM");
p7_hmmfile_Close(hfp);
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, 0);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, 0, p7_UNIGLOCAL); /* that sets N,C,J to generate nothing */
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
if (esl_opt_GetBoolean(go, "-p")) tr = p7_trace_CreateWithPP();
else tr = p7_trace_Create();
sq = esl_sq_CreateDigital(abc);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
p7_ProfileEmit(r, hmm, gm, bg, sq, tr);
esl_sq_SetName(sq, "random");
if (! esl_opt_GetBoolean(go, "-b"))
{
if (esl_opt_GetBoolean(go, "-p"))
for (z = 0; z < tr->N; z++)
if (tr->i[z] > 0) tr->pp[z] = esl_random(r);
ad = p7_alidisplay_Create(tr, 0, om, sq);
p7_alidisplay_Print(stdout, ad, 40, 80, FALSE);
p7_alidisplay_Destroy(ad);
}
p7_trace_Reuse(tr);
esl_sq_Reuse(sq);
}
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
esl_sq_Destroy(sq);
p7_trace_Destroy(tr);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(r);
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
