int main(int argc, char argv[])
{
int arr[] = {3, 5, 2, 7, 0};
int len = sizeof(arr)/sizeof(int);
select_sort(arr, len);
print_res(arr, len);
return 0;
}
int main()
{
demo::data d = {0, 0};
print_res ("a", d.a, "b", d.b);
// Increment "manually"
d.a += 1;
d.b += 1;
print_res ("a", d.a, "b", d.b);
// Increment thanks to macro and concatenation
#define INCREMENT(s,VAR) s.VAR += 1
INCREMENT (d, a);
INCREMENT (d, b);
print_res ("a", d.a, "b", d.b);
// Increment thanks to Boost preprocessor
#define DATA_NAMES (2, (a, b))
INCREMENT (d, BOOST_PP_ARRAY_ELEM(0, DATA_NAMES));
INCREMENT (d, BOOST_PP_ARRAY_ELEM(1, DATA_NAMES));
print_res ("a", d.a, "b", d.b);
// Increment and loop thanks to Boost preprocessor
#define BOOST_PP_LOCAL_MACRO(n) \
INCREMENT (d, BOOST_PP_ARRAY_ELEM(n, DATA_NAMES));
// Loop limits (from 0 to N_DATA)
#define BOOST_PP_LOCAL_LIMITS (0,1)
// Execute the loop
#include BOOST_PP_LOCAL_ITERATE()
print_res ("a", d.a, "b", d.b);
return EXIT_SUCCESS;
}
// Stolen from aclnt::init_call
static void
printreply (aclnt_cb cb, str name, void *res,
void (*print_res) (const void *, const strbuf *, int,
const char *, const char *),
clnt_stat err)
{
if (aclnttrace >= 3) {
if (err)
warn << "ACLNT_TRACE:" << tracetime ()
<< " reply " << name << ": " << err << "\n";
else if (aclnttrace >= 4) {
warn << "ACLNT_TRACE:" << tracetime ()
<< " reply " << name << "\n";
if (aclnttrace >= 5 && print_res)
print_res (res, NULL, aclnttrace - 4, "REPLY", "");
}
}
(*cb) (err);
}
int main()
{
test_set_ieee_double_precision();
CGAL::FPU_CW_t backup = CGAL::FPU_get_cw();
bool flag = true;
flag = flag && (FPU_empiric_test() == CGAL_FE_TONEAREST);
std::cout << "default: ";
print_res(flag);
// Should be a no-op.
CGAL::FPU_set_cw(CGAL::FPU_get_cw());
flag = flag && (FPU_empiric_test() == CGAL_FE_TONEAREST);
std::cout << "get/set: ";
print_res(flag);
if (!flag) print_rounding_name(FPU_empiric_test());
// Rounding to zero.
CGAL::FPU_set_cw(CGAL_FE_TOWARDZERO);
flag = flag && (FPU_empiric_test() == CGAL_FE_TOWARDZERO);
std::cout << "zero : ";
print_res(flag);
if (!flag) print_rounding_name(FPU_empiric_test());
// Rounding to infinity.
CGAL::FPU_set_cw(CGAL_FE_UPWARD);
flag = flag && (FPU_empiric_test() == CGAL_FE_UPWARD);
std::cout << "+inf : ";
print_res(flag);
if (!flag) print_rounding_name(FPU_empiric_test());
// Rounding to minus infinity.
CGAL::FPU_set_cw(CGAL_FE_DOWNWARD);
flag = flag && (FPU_empiric_test() == CGAL_FE_DOWNWARD);
std::cout << "-inf : ";
print_res(flag);
if (!flag) print_rounding_name(FPU_empiric_test());
// Rounding to nearest.
CGAL::FPU_set_cw(CGAL_FE_TONEAREST);
flag = flag && (FPU_empiric_test() == CGAL_FE_TONEAREST);
std::cout << "near : ";
print_res(flag);
if (!flag) print_rounding_name(FPU_empiric_test());
CGAL::FPU_set_cw(backup); // We restore it, as this gets checked
return (int) !flag;
}
bool
copydb (mongoc_client_t *client, const char *other_host_and_port)
{
mongoc_database_t *admindb;
bson_t *command;
bson_t reply;
bson_error_t error;
bool res;
BSON_ASSERT (other_host_and_port);
/* Must do this from the admin db */
admindb = mongoc_client_get_database (client, "admin");
command = BCON_NEW ("copydb",
BCON_INT32 (1),
"fromdb",
BCON_UTF8 ("test"),
"todb",
BCON_UTF8 ("test2"),
/* If you want from a different host */
"fromhost",
BCON_UTF8 (other_host_and_port));
res =
mongoc_database_command_simple (admindb, command, NULL, &reply, &error);
if (!res) {
fprintf (stderr, "Error with copydb: %s\n", error.message);
goto cleanup;
}
/* Do something with the reply */
print_res (&reply);
cleanup:
bson_destroy (&reply);
bson_destroy (command);
mongoc_database_destroy (admindb);
return res;
}
void
run(int r)
{
char buf[128];
printf("\t%s: run %d\n", __wt_page_type_string(page_type), r);
CHECK(system("rm -f WiredTiger* __slvg.*") == 0);
CHECK((res_fp = fopen(RSLT, "w")) != NULL);
/*
* Each run builds the LOAD file, and then appends the first page of
* the LOAD file into the SLVG file. The SLVG file is then salvaged,
* verified, and dumped into the DUMP file, which is compared to the
* results file, which are the expected results.
*/
switch (r) {
case 1:
/*
* Smoke test: empty files.
*/
build(0, 0, 0); copy(0, 0);
break;
case 2:
/*
* Smoke test:
* Sequential pages, all pages should be kept.
*/
build(100, 100, 20); copy(6, 1);
build(200, 200, 20); copy(7, 21);
build(300, 300, 20); copy(8, 41);
print_res(100, 100, 20);
print_res(200, 200, 20);
print_res(300, 300, 20);
break;
case 3:
/*
* Smoke test:
* Sequential pages, all pages should be kept.
*/
build(100, 100, 20); copy(8, 1);
build(200, 200, 20); copy(7, 21);
build(300, 300, 20); copy(6, 41);
print_res(100, 100, 20);
print_res(200, 200, 20);
print_res(300, 300, 20);
break;
case 4:
/*
* Case #1:
* 3 pages, each with 20 records starting with the same record
* and sequential LSNs; salvage should leave the page with the
* largest LSN.
*/
build(100, 100, 20); copy(6, 1);
build(100, 200, 20); copy(7, 1);
build(100, 300, 20); copy(8, 1);
print_res(100, 300, 20);
break;
case 5:
/*
* Case #1:
* 3 pages, each with 20 records starting with the same record
* and sequential LSNs; salvage should leave the page with the
* largest LSN.
*/
build(100, 100, 20); copy(6, 1);
build(100, 200, 20); copy(8, 1);
build(100, 300, 20); copy(7, 1);
print_res(100, 200, 20);
break;
case 6:
/*
* Case #1:
* 3 pages, each with 20 records starting with the same record
* and sequential LSNs; salvage should leave the page with the
* largest LSN.
*/
build(100, 100, 20); copy(8, 1);
build(100, 200, 20); copy(7, 1);
build(100, 300, 20); copy(6, 1);
print_res(100, 100, 20);
break;
case 7:
/*
* Case #2:
* The second page overlaps the beginning of the first page, and
* the first page has a higher LSN.
*/
build(110, 100, 20); copy(7, 11);
build(100, 200, 20); copy(6, 1);
print_res(100, 200, 10);
print_res(110, 100, 20);
break;
case 8:
/*
* Case #2:
* The second page overlaps the beginning of the first page, and
* the second page has a higher LSN.
*/
build(110, 100, 20); copy(6, 11);
build(100, 200, 20); copy(7, 1);
print_res(100, 200, 20);
print_res(120, 110, 10);
break;
case 9:
/*
* Case #3:
* The second page overlaps with the end of the first page, and
* the first page has a higher LSN.
*/
build(100, 100, 20); copy(7, 1);
build(110, 200, 20); copy(6, 11);
print_res(100, 100, 20);
print_res(120, 210, 10);
break;
case 10:
/*
* Case #3:
* The second page overlaps with the end of the first page, and
* the second page has a higher LSN.
*/
build(100, 100, 20); copy(6, 1);
build(110, 200, 20); copy(7, 11);
print_res(100, 100, 10);
print_res(110, 200, 20);
break;
case 11:
/*
* Case #4:
* The second page is a prefix of the first page, and the first
* page has a higher LSN.
*/
build(100, 100, 20); copy(7, 1);
build(100, 200, 5); copy(6, 1);
print_res(100, 100, 20);
break;
case 12:
/*
* Case #4:
* The second page is a prefix of the first page, and the second
* page has a higher LSN.
*/
build(100, 100, 20); copy(6, 1);
build(100, 200, 5); copy(7, 1);
print_res(100, 200, 5);
print_res(105, 105, 15);
break;
case 13:
/*
* Case #5:
* The second page is in the middle of the first page, and the
* first page has a higher LSN.
*/
build(100, 100, 40); copy(7, 1);
build(110, 200, 10); copy(6, 11);
print_res(100, 100, 40);
break;
case 14:
/*
* Case #5:
* The second page is in the middle of the first page, and the
* second page has a higher LSN.
*/
build(100, 100, 40); copy(6, 1);
build(110, 200, 10); copy(7, 11);
print_res(100, 100, 10);
print_res(110, 200, 10);
print_res(120, 120, 20);
break;
case 15:
/*
* Case #6:
* The second page is a suffix of the first page, and the first
* page has a higher LSN.
*/
build(100, 100, 40); copy(7, 1);
build(130, 200, 10); copy(6, 31);
print_res(100, 100, 40);
break;
case 16:
/*
* Case #6:
* The second page is a suffix of the first page, and the second
* page has a higher LSN.
*/
build(100, 100, 40); copy(6, 1);
build(130, 200, 10); copy(7, 31);
print_res(100, 100, 30);
print_res(130, 200, 10);
break;
case 17:
/*
* Case #9:
* The first page is a prefix of the second page, and the first
* page has a higher LSN.
*/
build(100, 100, 20); copy(7, 1);
build(100, 200, 40); copy(6, 1);
print_res(100, 100, 20);
print_res(120, 220, 20);
break;
case 18:
/*
* Case #9:
* The first page is a prefix of the second page, and the second
* page has a higher LSN.
*/
build(100, 100, 20); copy(6, 1);
build(100, 200, 40); copy(7, 1);
print_res(100, 200, 40);
break;
case 19:
/*
* Case #10:
* The first page is a suffix of the second page, and the first
* page has a higher LSN.
*/
build(130, 100, 10); copy(7, 31);
build(100, 200, 40); copy(6, 1);
print_res(100, 200, 30);
print_res(130, 100, 10);
break;
case 20:
/*
* Case #10:
* The first page is a suffix of the second page, and the second
* page has a higher LSN.
*/
build(130, 100, 10); copy(6, 31);
build(100, 200, 40); copy(7, 1);
print_res(100, 200, 40);
break;
case 21:
/*
* Case #11:
* The first page is in the middle of the second page, and the
* first page has a higher LSN.
*/
build(110, 100, 10); copy(7, 11);
build(100, 200, 40); copy(6, 1);
print_res(100, 200, 10);
print_res(110, 100, 10);
print_res(120, 220, 20);
break;
case 22:
/*
* Case #11:
* The first page is in the middle of the second page, and the
* second page has a higher LSN.
*/
build(110, 100, 10); copy(6, 11);
build(100, 200, 40); copy(7, 1);
print_res(100, 200, 40);
break;
case 23:
/*
* Column-store only: missing an initial key range of 99
* records.
*/
build(100, 100, 10); copy(1, 100);
empty(99);
print_res(100, 100, 10);
break;
case 24:
/*
* Column-store only: missing a middle key range of 37
* records.
*/
build(100, 100, 10); copy(1, 1);
build(138, 138, 10); copy(1, 48);
print_res(100, 100, 10);
empty(37);
print_res(138, 138, 10);
break;
default:
fprintf(stderr, "salvage: %d: no such test\n", r);
exit(EXIT_FAILURE);
}
CHECK(fclose(res_fp) == 0);
process();
snprintf(buf, sizeof(buf), "cmp %s %s > /dev/null", DUMP, RSLT);
if (system(buf)) {
fprintf(stderr,
"check failed, salvage results were incorrect\n");
exit(EXIT_FAILURE);
}
}
static int
print_encode(struct html *h, const char *p, int norecurse)
{
size_t sz;
int len, nospace;
const char *seq;
enum roffdeco deco;
static const char rejs[6] = { '\\', '<', '>', '&', ASCII_HYPH, '\0' };
nospace = 0;
for (; *p; p++) {
sz = strcspn(p, rejs);
fwrite(p, 1, sz, stdout);
p += /* LINTED */
sz;
if ('<' == *p) {
printf("<");
continue;
} else if ('>' == *p) {
printf(">");
continue;
} else if ('&' == *p) {
printf("&");
continue;
} else if (ASCII_HYPH == *p) {
/*
* Note: "soft hyphens" aren't graphically
* displayed when not breaking the text; we want
* them to be displayed.
*/
/*printf("­");*/
putchar('-');
continue;
} else if ('\0' == *p)
break;
seq = ++p;
len = a2roffdeco(&deco, &seq, &sz);
switch (deco) {
case (DECO_RESERVED):
print_res(h, seq, sz);
break;
case (DECO_SSPECIAL):
/* FALLTHROUGH */
case (DECO_SPECIAL):
print_spec(h, deco, seq, sz);
break;
case (DECO_PREVIOUS):
/* FALLTHROUGH */
case (DECO_BOLD):
/* FALLTHROUGH */
case (DECO_ITALIC):
/* FALLTHROUGH */
case (DECO_ROMAN):
if (norecurse)
break;
print_metaf(h, deco);
break;
default:
break;
}
p += len - 1;
if (DECO_NOSPACE == deco && '\0' == *(p + 1))
nospace = 1;
}
return(nospace);
}
int
main(int argc, char *argv[])
{
int count;
seq_t seq1, seq2;
hash_env_t he;
collec_t res, rev_res;
#if defined(DEBUG) && (DEBUG > 1)
mcheck(NULL);
mtrace();
#endif
argv0 = argv[0];
if (setlocale(LC_ALL, "POSIX") == NULL)
fprintf(stderr, "%s: Warning: could not set locale to POSIX\n", argv[0]);
signal(SIGSEGV, bug_handler);
#ifndef __MINGW32__
signal(SIGBUS, bug_handler);
#endif
/* Default options. */
options.C = DEFAULT_C;
options.cutoff = DIST_CUTOFF;
options.gapPct = DEFAULT_GAPPCT;
options.intron_window = 6;
options.K = DEFAULT_K;
options.splice_type_list = "GTAG,GCAG,GTAC,ATAC";
options.nbSplice = 4;
options.scoreSplice_window = 10;
options.mismatchScore = MISMATCH;
options.reverse = 2;
options.matchScore = MATCH;
options.W = DEFAULT_W;
options.X = DEFAULT_X;
options.filterPct = DEFAULT_FILTER;
options.minScore_cutoff = MATCH_CUTOFF;
while (1) {
int c = getopt(argc, argv, "A:C:c:E:f:g:I:K:L:M:o:q:R:r:W:X:");
if (c == -1)
break;
switch (c) {
case 'A':
options.ali_flag = atoi(optarg);
if (options.ali_flag < 0 || options.ali_flag > 4)
fatal("A must be one of 0, 1, 2, 3, or 4.\n");
break;
case 'C': {
int val = atoi(optarg);
if (val < 0)
fatal("Value for option C must be non-negative.\n");
options.C = val;
break;
}
case 'c': {
int val = atoi(optarg);
if (val < 0)
fatal("Value for option c must be non-negative.\n");
options.minScore_cutoff = val;
break;
}
case 'E':
options.cutoff = atoi(optarg);
if (options.cutoff < 3 || options.cutoff > 10)
fatal("Cutoff (E) must be within [3,10].\n");
break;
case 'f':
options.filterPct = atoi(optarg);
if (options.filterPct > 100)
fatal("Filter in percent (f) must be within [0,100].\n");
break;
case 'g':
options.gapPct = atoi(optarg);
break;
case 'I':
options.intron_window = atoi(optarg);
break;
case 'K': {
int val = atoi(optarg);
if (val < 0)
fatal("Value for option K must be non-negative.\n");
options.K = val;
break;
}
case 'L': {
size_t i;
size_t len = strlen(optarg);
options.splice_type_list = optarg;
options.nbSplice = 1;
if (len % 5 != 4)
fatal("Splice types list has illegal length (%zu)\n", len);
for (i = 0; i < len; i++)
if (i % 5 == 4) {
if (options.splice_type_list[i] != ',')
fatal("Comma expected instead of %c at position %zu"
"in splice types list.\n",
options.splice_type_list[i], i);
options.nbSplice += 1;
} else {
if (options.splice_type_list[i] != 'A'
&& options.splice_type_list[i] != 'C'
&& options.splice_type_list[i] != 'G'
&& options.splice_type_list[i] != 'T')
fatal("Expected 'A', 'C', 'G' or 'T' instead of '%c' at"
"position %zu in splice types list.\n",
options.splice_type_list[i], i);
}
break;
}
case 'M': {
int val = atoi(optarg);
if (val < 0)
fatal("Value for option M must be non-negative.\n");
options.scoreSplice_window = val;
break;
}
case 'o':
options.dnaOffset = atoi(optarg);
break;
case 'q':
options.mismatchScore = atoi(optarg);
break;
case 'R':
options.reverse = atoi(optarg);
if (options.reverse < 0 || options.reverse > 2)
fatal("R must be one of 0, 1, or 2.\n");
break;
case 'r':
options.matchScore = atoi(optarg);
break;
case 'W':
options.W = atoi(optarg);
if (options.W < 1 || options.W > 15)
fatal("W must be within [1,15].\n");
break;
case 'X':
options.X = atoi(optarg);
if (options.X < 1)
fatal("X must be positive.\n");
break;
case '?':
break;
default:
fprintf(stderr, "?? getopt returned character code 0%o ??\n", c);
}
}
if (optind + 2 != argc) {
fprintf(stderr, Usage, argv[0], options.ali_flag, options.C,
options.minScore_cutoff, options.cutoff,
options.filterPct, options.gapPct, options.intron_window,
options.K, options.splice_type_list, options.scoreSplice_window,
options.dnaOffset, options.mismatchScore, options.reverse,
options.matchScore, options.W, options.X);
return 1;
}
/* read seq1 */
init_seq(argv[optind], &seq1);
if (get_next_seq(&seq1, options.dnaOffset, 1) != 0)
fatal("Cannot read sequence from %s.\n", argv[optind]);
strncpy(dna_seq_head, seq1.header, 256);
/* read seq2 */
init_seq(argv[optind + 1], &seq2);
if (get_next_seq(&seq2, 0, 0) != 0)
fatal("Cannot read sequence from %s.\n", argv[optind + 1]);
init_encoding();
init_hash_env(&he, options.W, seq1.seq, seq1.len);
init_col(&res, 1);
init_col(&rev_res, 1);
bld_table(&he);
init_splice_junctions();
count = 0;
while (!count || get_next_seq(&seq2, 0, 0) == 0) {
unsigned int curRes;
strncpy(rna_seq_head, seq2.header, 256);
++count;
switch (options.reverse) {
case 0:
SIM4(&he, &seq2, &res);
break;
case 2:
SIM4(&he, &seq2, &res);
case 1:
seq_revcomp_inplace(&seq2);
SIM4(&he, &seq2, &rev_res);
break;
default:
fatal ("Unrecognized request for EST orientation.\n");
}
/* Keep only the best matches, according to filterPct. */
if (options.filterPct > 0) {
unsigned int max_nmatches = 0;
for (curRes = 0; curRes < rev_res.nb; curRes++) {
result_p_t r = rev_res.e.result[curRes];
if (r->st.nmatches > max_nmatches)
max_nmatches = r->st.nmatches;
}
for (curRes = 0; curRes < res.nb; curRes++) {
result_p_t r = res.e.result[curRes];
if (r->st.nmatches > max_nmatches)
max_nmatches = r->st.nmatches;
}
max_nmatches = (max_nmatches * options.filterPct) / 100;
for (curRes = 0; curRes < rev_res.nb; curRes++) {
result_p_t r = rev_res.e.result[curRes];
if (r->st.nmatches < max_nmatches)
r->st.nmatches = 0;
}
for (curRes = 0; curRes < res.nb; curRes++) {
result_p_t r = res.e.result[curRes];
if (r->st.nmatches < max_nmatches)
r->st.nmatches = 0;
}
}
/* Now, print results. */
for (curRes = 0; curRes < rev_res.nb; curRes++)
print_res(rev_res.e.result[curRes], 1, &seq1, &seq2);
rev_res.nb = 0;
if (options.reverse && options.ali_flag)
/* reverse-complement back seq2 for alignment */
seq_revcomp_inplace(&seq2);
for (curRes = 0; curRes < res.nb; curRes++)
print_res(res.e.result[curRes], 0, &seq1, &seq2);
res.nb = 0;
}
#ifdef DEBUG
fprintf(stderr, "DEBUG mode: freeing all memory...\n");
fflush(stdout);
fflush(stderr);
free_hash_env(&he);
free_seq(&seq1);
free_seq(&seq2);
free(options.splice);
free(res.e.elt);
free(rev_res.e.elt);
#endif
return 0;
}
bool map_reduce_basic (mongoc_database_t* database)
{
bson_t reply;
bson_t* command;
bool res;
bson_error_t error;
mongoc_cursor_t* cursor;
const bson_t* doc;
bool map_reduce_done = false;
bool query_done = false;
const char* out_collection_name = "outCollection";
mongoc_collection_t* out_collection;
/* Empty find query */
bson_t find_query = BSON_INITIALIZER;
/* Construct the mapReduce command */
/* Other arguments can also be specified here, like "query" or
"limit" and so on */
command = BCON_NEW ("mapReduce", BCON_UTF8 (COLLECTION_NAME),
"map", BCON_CODE (MAPPER),
"reduce", BCON_CODE (REDUCER),
"out", BCON_UTF8 (out_collection_name));
res = mongoc_database_command_simple (database, command, NULL,
&reply, &error);
map_reduce_done = true;
if (!res) {
fprintf (stderr, "MapReduce failed: %s\n", error.message);
goto cleanup;
}
/* Do something with the reply (it doesn't contain the mapReduce results) */
print_res (&reply);
/* Now we'll query outCollection to see what the results are */
out_collection = mongoc_database_get_collection (database,
out_collection_name);
cursor = mongoc_collection_find_with_opts (out_collection, &find_query,
NULL, NULL);
query_done = true;
/* Do something with the results */
while (mongoc_cursor_next (cursor, &doc)) {
print_res (doc);
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "ERROR: %s\n", error.message);
res = false;
goto cleanup;
}
cleanup:
/* cleanup */
if (query_done) {
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (out_collection);
}
if (map_reduce_done) {
bson_destroy (&reply);
bson_destroy (command);
}
return res;
}
int
gsl_monte_vegas_integrate (gsl_monte_function * f,
double xl[], double xu[],
size_t dim, size_t calls,
gsl_rng * r,
gsl_monte_vegas_state * state,
double *result, double *abserr)
{
double cum_int, cum_sig;
size_t i, k, it;
if (dim != state->dim)
{
GSL_ERROR ("number of dimensions must match allocated size", GSL_EINVAL);
}
for (i = 0; i < dim; i++)
{
if (xu[i] <= xl[i])
{
GSL_ERROR ("xu must be greater than xl", GSL_EINVAL);
}
if (xu[i] - xl[i] > GSL_DBL_MAX)
{
GSL_ERROR ("Range of integration is too large, please rescale",
GSL_EINVAL);
}
}
if (state->stage == 0)
{
init_grid (state, xl, xu, dim);
if (state->verbose >= 0)
{
print_lim (state, xl, xu, dim);
}
}
if (state->stage <= 1)
{
state->wtd_int_sum = 0;
state->sum_wgts = 0;
state->chi_sum = 0;
state->it_num = 1;
state->samples = 0;
state->chisq = 0;
}
if (state->stage <= 2)
{
unsigned int bins = state->bins_max;
unsigned int boxes = 1;
if (state->mode != GSL_VEGAS_MODE_IMPORTANCE_ONLY)
{
/* shooting for 2 calls/box */
boxes = floor (pow (calls / 2.0, 1.0 / dim));
state->mode = GSL_VEGAS_MODE_IMPORTANCE;
if (2 * boxes >= state->bins_max)
{
/* if bins/box < 2 */
int box_per_bin = GSL_MAX (boxes / state->bins_max, 1);
bins = GSL_MIN(boxes / box_per_bin, state->bins_max);
boxes = box_per_bin * bins;
state->mode = GSL_VEGAS_MODE_STRATIFIED;
}
}
{
double tot_boxes = gsl_pow_int ((double) boxes, dim);
state->calls_per_box = GSL_MAX (calls / tot_boxes, 2);
calls = state->calls_per_box * tot_boxes;
}
/* total volume of x-space/(avg num of calls/bin) */
state->jac = state->vol * pow ((double) bins, (double) dim) / calls;
state->boxes = boxes;
/* If the number of bins changes from the previous invocation, bins
are expanded or contracted accordingly, while preserving bin
density */
if (bins != state->bins)
{
resize_grid (state, bins);
if (state->verbose > 1)
{
print_grid (state, dim);
}
}
if (state->verbose >= 0)
{
print_head (state,
dim, calls, state->it_num, state->bins, state->boxes);
}
}
state->it_start = state->it_num;
cum_int = 0.0;
cum_sig = 0.0;
for (it = 0; it < state->iterations; it++)
{
double intgrl = 0.0, intgrl_sq = 0.0;
double tss = 0.0;
double wgt, var, sig;
size_t calls_per_box = state->calls_per_box;
double jacbin = state->jac;
double *x = state->x;
coord *bin = state->bin;
state->it_num = state->it_start + it;
reset_grid_values (state);
init_box_coord (state, state->box);
do
{
volatile double m = 0, q = 0;
double f_sq_sum = 0.0;
for (k = 0; k < calls_per_box; k++)
{
volatile double fval;
double bin_vol;
random_point (x, bin, &bin_vol, state->box, xl, xu, state, r);
fval = jacbin * bin_vol * GSL_MONTE_FN_EVAL (f, x);
/* recurrence for mean and variance (sum of squares) */
{
double d = fval - m;
m += d / (k + 1.0);
q += d * d * (k / (k + 1.0));
}
if (state->mode != GSL_VEGAS_MODE_STRATIFIED)
{
double f_sq = fval * fval;
accumulate_distribution (state, bin, f_sq);
}
}
intgrl += m * calls_per_box;
f_sq_sum = q * calls_per_box;
tss += f_sq_sum;
if (state->mode == GSL_VEGAS_MODE_STRATIFIED)
{
accumulate_distribution (state, bin, f_sq_sum);
}
}
while (change_box_coord (state, state->box));
/* Compute final results for this iteration */
var = tss / (calls_per_box - 1.0) ;
if (var > 0)
{
wgt = 1.0 / var;
}
else if (state->sum_wgts > 0)
{
wgt = state->sum_wgts / state->samples;
}
else
{
wgt = 0.0;
}
intgrl_sq = intgrl * intgrl;
sig = sqrt (var);
state->result = intgrl;
state->sigma = sig;
if (wgt > 0.0)
{
double sum_wgts = state->sum_wgts;
double wtd_int_sum = state->wtd_int_sum;
double m = (sum_wgts > 0) ? (wtd_int_sum / sum_wgts) : 0;
double q = intgrl - m;
state->samples++ ;
state->sum_wgts += wgt;
state->wtd_int_sum += intgrl * wgt;
state->chi_sum += intgrl_sq * wgt;
cum_int = state->wtd_int_sum / state->sum_wgts;
cum_sig = sqrt (1 / state->sum_wgts);
#if USE_ORIGINAL_CHISQ_FORMULA
/* This is the chisq formula from the original Lepage paper. It
computes the variance from <x^2> - <x>^2 and can suffer from
catastrophic cancellations, e.g. returning negative chisq. */
if (state->samples > 1)
{
state->chisq = (state->chi_sum - state->wtd_int_sum * cum_int) /
(state->samples - 1.0);
}
#else
/* The new formula below computes exactly the same quantity as above
but using a stable recurrence */
if (state->samples == 1) {
state->chisq = 0;
} else {
state->chisq *= (state->samples - 2.0);
state->chisq += (wgt / (1 + (wgt / sum_wgts))) * q * q;
state->chisq /= (state->samples - 1.0);
}
#endif
}
else
{
cum_int += (intgrl - cum_int) / (it + 1.0);
cum_sig = 0.0;
}
if (state->verbose >= 0)
{
print_res (state,
state->it_num, intgrl, sig, cum_int, cum_sig,
state->chisq);
if (it + 1 == state->iterations && state->verbose > 0)
{
print_grid (state, dim);
}
}
if (state->verbose > 1)
{
print_dist (state, dim);
}
refine_grid (state);
if (state->verbose > 1)
{
print_grid (state, dim);
}
}
/* By setting stage to 1 further calls will generate independent
estimates based on the same grid, although it may be rebinned. */
state->stage = 1;
*result = cum_int;
*abserr = cum_sig;
return GSL_SUCCESS;
}
