/* 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; }