/**
* @brief Read in files with arrays and join them into a single file
* @param argc
* @param argv[]
* @return
*/
int main (int argc, char *argv[]) {
AnyOption opt;
opt.setFlag ("help", 'h'); /* a flag (takes no argument), supporting long and short form */
opt.setOption ("verbose", 'v');
opt.setOption ("random", 'r');
opt.addUsage ("OA: unittest: Perform some checks on the code");
opt.addUsage ("Usage: unittest [OPTIONS]");
opt.addUsage ("");
opt.addUsage (" -v --verbose Print documentation");
opt.addUsage (" -r --random Seed for random number generator");
opt.processCommandArgs (argc, argv);
int verbose = opt.getIntValue ('v', 1);
int random = opt.getIntValue ('r', 0);
if (opt.getFlag ("help") || opt.getFlag ('h')) {
opt.printUsage ();
exit (0);
}
if (verbose) {
print_copyright ();
}
if (verbose >= 2) {
print_options (std::cout);
}
oaunittest (verbose, 1, random);
return 0;
}
/**
* @brief Read in files with arrays and join them into a single file
* @param argc
* @param argv[]
* @return
*/
int main (int argc, char *argv[]) {
AnyOption opt;
/* parse command line options */
opt.setFlag ("help", 'h'); /* a flag (takes no argument), supporting long and short form */
opt.setOption ("output", 'o');
opt.setOption ("format", 'f');
opt.setOption ("verbose", 'v');
opt.addUsage ("Orthonal Array Convert: convert array file into a different format");
opt.addUsage ("Usage: oaconvert [OPTIONS] [INPUTFILE] [OUTPUTFILE]");
opt.addUsage ("");
opt.addUsage (" -h --help Prints this help ");
opt.addUsage (" -f [FORMAT] Output format (default: TEXT, or BINARY) ");
opt.processCommandArgs (argc, argv);
int verbose = opt.getIntValue ("verbose", 2);
if (verbose > 0)
print_copyright ();
/* parse options */
if (opt.getFlag ("help") || opt.getFlag ('h') || opt.getArgc () == 0) {
opt.printUsage ();
exit (0);
}
const std::string outputprefix = opt.getStringValue ('o', "");
std::string format = opt.getStringValue ('f', "BINARY");
arrayfile::arrayfilemode_t mode = arrayfile_t::parseModeString (format);
if (opt.getArgc () != 2) {
opt.printUsage ();
exit (0);
}
std::string infile = opt.getArgv (0);
std::string outfile = opt.getArgv (1);
convert_array_file(infile, outfile, mode, verbose);
return 0;
}
/**
* @brief Read in a list of array and check for each of the arrays whether they are in LMC form or not
* @param argc
* @param argv[]
* @return
*/
int main (int argc, char *argv[]) {
char *fname;
int correct = 0, wrong = 0;
/* parse command line options */
AnyOption opt;
opt.setFlag ("help", 'h'); /* a flag (takes no argument), supporting long and short form */
opt.setOption ("loglevel", 'l');
opt.setOption ("oaconfig", 'c');
opt.setOption ("check");
opt.setOption ("strength", 's');
opt.setOption ("prune", 'p');
opt.setOption ("output", 'o');
opt.setOption ("mode", 'm');
opt.addUsage ("oacheck: Check arrays for LMC form or reduce to LMC form");
opt.addUsage ("Usage: oacheck [OPTIONS] [ARRAYFILE]");
opt.addUsage ("");
opt.addUsage (" -h --help Prints this help");
opt.addUsage (" -l [LEVEL] --loglevel [LEVEL] Set loglevel to number");
opt.addUsage (" -s [STRENGTH] --strength [STRENGTH] Set strength to use in checking");
std::string ss = " --check [MODE] Select mode: ";
ss +=
printfstring ("%d (default: check ), %d (reduce to LMC form), %d (apply random transformation and reduce)",
MODE_CHECK, MODE_REDUCE, MODE_REDUCERANDOM); //
for (int i = 3; i < ncheckopts; ++i)
ss += printfstring (", %d (%s)", static_cast< checkmode_t > (i), modeString ((checkmode_t)i).c_str ());
opt.addUsage (ss.c_str ());
opt.addUsage (" -o [OUTPUTFILE] Output file for LMC reduction");
opt.processCommandArgs (argc, argv);
algorithm_t algmethod = (algorithm_t)opt.getIntValue ("mode", MODE_AUTOSELECT);
int loglevel = NORMAL;
if (opt.getValue ("loglevel") != NULL || opt.getValue ('l') != NULL)
loglevel = atoi (opt.getValue ('l')); // set custom loglevel
setloglevel (loglevel);
if (checkloglevel (QUIET)) {
print_copyright ();
}
if (opt.getFlag ("help") || opt.getFlag ('h') || opt.getArgc () == 0) {
opt.printUsage ();
return 0;
}
checkmode_t mode = MODE_CHECK;
if (opt.getValue ("check") != NULL)
mode = (checkmode_t)atoi (opt.getValue ("check")); // set custom loglevel
if (mode >= ncheckopts)
mode = MODE_CHECK;
logstream (QUIET) << "#time start: " << currenttime () << std::endl;
double t = get_time_ms ();
t = 1e3 * (t - floor (t));
srand (t);
int prune = opt.getIntValue ('p', 0);
fname = opt.getArgv (0);
setloglevel (loglevel);
int strength = opt.getIntValue ('s', 2);
if (strength < 1 || strength > 10) {
printf ("Strength specfied (t=%d) is invalid\n", strength);
exit (1);
} else {
log_print (NORMAL, "Using strength %d to increase speed of checking arrays\n", strength);
}
arraylist_t outputlist;
char *outputfile = 0;
bool writeoutput = false;
if (opt.getValue ("output") != NULL) {
writeoutput = true;
outputfile = opt.getValue ('o');
}
arrayfile_t *afile = new arrayfile_t (fname);
if (!afile->isopen ()) {
printf ("Problem opening %s\n", fname);
exit (1);
}
logstream (NORMAL) << "Check mode: " << mode << " (" << modeString (mode) << ")" << endl;
/* start checking */
double Tstart = get_time_ms (), dt;
int index;
array_link al (afile->nrows, afile->ncols, -1);
for (int i = 0; i < afile->narrays; i++) {
index = afile->read_array (al);
array_t *array = al.array;
arraydata_t arrayclass = arraylink2arraydata (al, 0, strength);
arrayclass.lmc_overflow_check ();
OAextend oaextend;
lmc_t result = LMC_NONSENSE;
LMCreduction_t *reduction = new LMCreduction_t (&arrayclass);
LMCreduction_t *randtest = new LMCreduction_t (&arrayclass);
array_link test_arraylink = al.clone();
array_t *testarray = test_arraylink.array;
randtest->transformation->randomize ();
reduction->setArray ( al);
/* variables needed within the switch statement */
switch (mode) {
case MODE_CHECK:
{
/* LMC test with reduction code */
reduction->mode = OA_TEST;
result = LMCcheck(al, arrayclass, oaextend, *reduction);
break;
}
case MODE_CHECKJ4: {
/* LMC test with special code */
reduction->mode = OA_TEST;
reduction->init_state = COPY;
oaextend.setAlgorithm (MODE_J4, &arrayclass);
result = LMCcheck (al, arrayclass, oaextend, *reduction);
break;
}
case MODE_REDUCEJ4: {
/* LMC test with special code */
reduction->mode = OA_REDUCE;
reduction->setArray (al);
result = LMCcheckj4 (al, arrayclass, *reduction, oaextend);
break;
}
case MODE_CHECK_SYMMETRY: {
myprintf("MODE_CHECK_SYMMETRY not supported any more");
exit(1);
}
case MODE_CHECKJ5X: {
oaextend.setAlgorithm (MODE_J5ORDERX, &arrayclass);
/* LMC test with special code */
reduction->mode = OA_TEST;
reduction->init_state = COPY;
result = LMCcheck (al, arrayclass, oaextend, *reduction);
break;
}
case MODE_CHECKJ5XFAST: {
oaextend.setAlgorithm (MODE_J5ORDERX, &arrayclass);
/* LMC test with special code */
reduction->mode = OA_TEST;
reduction->init_state = COPY;
if (1) {
array_link al (array, arrayclass.N, arrayclass.ncols, al.INDEX_NONE);
reduction->updateSDpointer (al);
}
result = LMCcheck (al, arrayclass, oaextend, *reduction);
break;
}
case MODE_REDUCEJ5X: {
OAextend oaextend;
oaextend.setAlgorithm (MODE_J5ORDERX, &arrayclass);
/* LMC test with special code */
printf ("oacheck: WARNING: MODE_CHECKJ5X: untested code, not complete\n");
reduction->mode = OA_REDUCE;
result = LMCcheck (al, arrayclass, oaextend, *reduction);
break;
}
case MODE_REDUCE:
/* LMC reduction */
{
reduction->mode = OA_REDUCE;
copy_array(array, reduction->array, arrayclass.N, arrayclass.ncols);
dyndata_t dynd = dyndata_t(arrayclass.N);
result = LMCreduction(array, array, &arrayclass, &dynd, reduction, oaextend);
break;
}
case MODE_REDUCERANDOM:
{
/* random LMC reduction */
oaextend.setAlgorithm(MODE_ORIGINAL, &arrayclass);
reduction->mode = OA_REDUCE;
randtest->transformation->apply(array, testarray);
copy_array(testarray, reduction->array, arrayclass.N, arrayclass.ncols);
reduction->init_state = INIT;
array_link alp = arrayclass.create_root(arrayclass.ncols, 1000);
reduction->setArray(alp);
dyndata_t dynd = dyndata_t(arrayclass.N);
result = LMCreduction(testarray, testarray, &arrayclass, &dynd, reduction, oaextend);
if (log_print(NORMAL, "")) {
reduction->transformation->show();
}
} break;
case MODE_REDUCETRAIN:
/* LMC reduction with train*/
reduction->mode = OA_REDUCE;
result = LMCreduction_train (al, &arrayclass, reduction, oaextend);
break;
case MODE_REDUCETRAINRANDOM:
/* random LMC reduction with train*/
reduction->mode = OA_REDUCE;
randtest->transformation->apply (array, testarray);
result = LMCreduction_train (test_arraylink, &arrayclass, reduction, oaextend);
break;
case MODE_HADAMARD:
myprintf("MODE_HADAMARD not supported any more\n");
exit(1);
default:
result = LMC_NONSENSE;
std::cout << "function " << __FUNCTION__ << "line " << __LINE__ << "Unknown mode" << std::endl;
exit (1);
break;
}
bool aequal;
switch (mode) {
case MODE_CHECK:
if (result == LMC_LESS) {
++wrong;
log_print (NORMAL, "Found array nr %i/%i NOT in lmc form:\n", i, afile->narrays);
} else {
++correct;
log_print (NORMAL, "Found array nr %i/%i in lmc form.\n", i, afile->narrays);
}
break;
case MODE_CHECKJ4:
case MODE_CHECKJ5X:
case MODE_CHECKJ5XFAST:
case MODE_CHECK_SYMMETRY:
if (result == LMC_LESS) {
++wrong;
log_print (NORMAL, "Found array nr %i/%i NOT in minimal form:\n", i, afile->narrays);
} else {
++correct;
log_print (NORMAL, "Found array nr %i/%i in minimal form.\n", i, afile->narrays);
}
break;
case MODE_REDUCE:
case MODE_REDUCEJ4:
case MODE_REDUCEJ5X:
case MODE_REDUCETRAIN:
aequal = std::equal (array, array + arrayclass.N * arrayclass.ncols, reduction->array);
if ((!aequal) || reduction->state == REDUCTION_CHANGED) {
++wrong;
log_print (QUIET, "Reduced array %i/%i to lmc form.\n", i, afile->narrays);
if (checkloglevel (NORMAL)) {
log_print (QUIET, "Original:\n");
print_array (array, afile->nrows, afile->ncols);
print_array ("Reduction:\n", reduction->array, afile->nrows, afile->ncols);
printf ("---------------\n");
}
if (checkloglevel (DEBUG)) {
cout << "Transformation: " << endl;
reduction->transformation->show (cout);
rowindex_t row;
colindex_t column;
array_diff (array, reduction->array, arrayclass.N, arrayclass.ncols, row, column);
cout << "Difference at: ";
printf (" row %d, col %d\n", row, column);
}
} else {
++correct;
log_print (QUIET, "Array %i/%i was already in lmc form:\n", i, afile->narrays);
}
break;
case MODE_REDUCETRAINRANDOM:
case MODE_REDUCERANDOM:
case MODE_REDUCEJ4RANDOM:
aequal = std::equal (array, array + arrayclass.N * arrayclass.ncols, reduction->array);
if (!aequal) {
++wrong;
log_print (SYSTEM,
"Array %i/%i: reduced random transformation not equal to original (BUG!)\n",
i, afile->narrays);
if (checkloglevel (NORMAL)) {
print_array ("Original:\n", array, afile->nrows, afile->ncols);
print_array ("Randomized:\n", testarray, afile->nrows, afile->ncols);
print_array ("Reduction:\n", reduction->array, afile->nrows, afile->ncols);
printf ("---------------\n");
}
} else {
++correct;
log_print (QUIET, "Array %i/%i: reduced random transformation to original\n", i,
afile->narrays);
}
break;
case MODE_HADAMARD:
break;
default:
std::cout << "function " << __FUNCTION__ << "line " << __LINE__ << "unknown mode" << std::endl;
break;
}
array_link al = array_link ((carray_t *)reduction->array, afile->nrows, afile->ncols, -1);
if (result == LMC_MORE || !prune) {
outputlist.push_back (al);
}
delete randtest;
delete reduction;
destroy_array (testarray);
}
afile->closefile ();
delete afile;
if (writeoutput) {
logstream (NORMAL) << "Writing output (" << outputlist.size () << " arrays)" << endl;
writearrayfile (outputfile, outputlist);
}
logstream (QUIET) << "#time end: " << currenttime () << std::endl;
return 0;
}
int main (int argc, char *argv[]) {
AnyOption opt;
/* parse command line options */
opt.setFlag ("help", 'h'); /* a flag (takes no argument), supporting long and short form */
opt.setOption ("output", 'o');
opt.setOption ("input", 'I');
opt.setOption ("rand", 'r');
opt.setOption ("verbose", 'v');
opt.setOption ("ii", 'i');
opt.setOption ("jj");
opt.setOption ("xx", 'x');
opt.setOption ("dverbose", 'd');
opt.setOption ("rows");
opt.setOption ("cols");
opt.setOption ("nrestarts");
opt.setOption ("niter");
opt.setOption ("mdebug", 'm');
opt.setOption ("oaconfig", 'c'); /* file that specifies the design */
opt.addUsage ("Orthonal Array: oatest: testing platform");
opt.addUsage ("Usage: oatest [OPTIONS] [FILE]");
opt.addUsage ("");
opt.addUsage (" -h --help Prints this help ");
opt.processCommandArgs (argc, argv);
double t0 = get_time_ms (), dt = 0;
int randvalseed = opt.getIntValue ('r', 1);
int ix = opt.getIntValue ('i', 1);
int r = opt.getIntValue ('r', 1);
int jj = opt.getIntValue ("jj", 5);
int xx = opt.getIntValue ('x', 0);
int niter = opt.getIntValue ("niter", 10);
int verbose = opt.getIntValue ("verbose", 1);
const char *input = opt.getValue ('I');
if (input == 0)
input = "test.oa";
srand (randvalseed);
if (randvalseed == -1) {
randvalseed = time (NULL);
printf ("random seed %d\n", randvalseed);
srand (randvalseed);
}
array_link array = exampleArray(0);
lmc_t lmc_type = LMCcheck(array);
array = array.randomperm();
array.showarray();
array_link reduced_array = reduceLMCform(array);
reduced_array.showarray();
exit(0);
try {
array_link al = exampleArray(r);
al.show();
al.showarray();
std::vector<int> sizes = array2modelmatrix_sizes(al);
display_vector(sizes); myprintf("\n");
MatrixFloat modelmatrix = array2modelmatrix(al, "i", 1);
array_link modelmatrixx = modelmatrix;
modelmatrixx.show();
modelmatrixx.showarray();
modelmatrix = array2modelmatrix(al, "main", 1);
modelmatrixx = modelmatrix;
modelmatrixx.show();
modelmatrixx.showarray();
exit(0);
}
catch (const std::exception &e) {
std::cerr << e.what() << std::endl;
throw;
}
{
array_link al = exampleArray (r);
array_transformation_t tt = reduceOAnauty (al);
array_link alx = tt.apply (al);
exit (0);
}
return 0;
}
/**
* @brief Main function for oaextendmpi and oaextendsingle
* @param argc
* @param argv[]
* @return
*/
int main (int argc, char *argv[]) {
#ifdef OAEXTEND_SINGLECORE
const int n_processors = 1;
const int this_rank = 0;
#else
MPI::Init (argc, argv);
const int n_processors = MPI::COMM_WORLD.Get_size ();
const int this_rank = MPI::COMM_WORLD.Get_rank ();
#endif
// printf("MPI: this_rank %d\n", this_rank);
/*----------SET STARTING ARRAY(S)-----------*/
if (this_rank != MASTER) {
#ifdef OAEXTEND_MULTICORE
slave_print (QUIET, "M: running core %d/%d\n", this_rank, n_processors);
#endif
algorithm_t algorithm = MODE_INVALID;
AnyOption *opt = parseOptions (argc, argv, algorithm);
OAextend oaextend;
oaextend.setAlgorithm (algorithm);
#ifdef OAEXTEND_MULTICORE
log_print (NORMAL, "slave: receiving algorithm int\n");
algorithm = (algorithm_t)receive_int_slave ();
oaextend.setAlgorithm (algorithm);
// printf("slave %d: receive algorithm %d\n", this_rank, algorithm);
#endif
extend_slave_code (this_rank, oaextend);
delete opt;
} else {
double Tstart = get_time_ms ();
int nr_extensions;
arraylist_t solutions, extensions;
algorithm_t algorithm = MODE_INVALID;
AnyOption *opt = parseOptions (argc, argv, algorithm);
print_copyright ();
int loglevel = opt->getIntValue ('l', NORMAL);
setloglevel (loglevel);
int dosort = opt->getIntValue ('s', 1);
int userowsymm = opt->getIntValue ("rowsymmetry", 1);
int maxk = opt->getIntValue ("maxk", 100000);
int initcolprev = opt->getIntValue ("initcolprev", 1);
const bool streaming = opt->getFlag ("streaming");
bool restart = false;
if (opt->getValue ("restart") != NULL || opt->getValue ('r') != NULL) {
restart = true;
}
const char *oaconfigfile = opt->getStringValue ('c', "oaconfig.txt");
const char *resultprefix = opt->getStringValue ('o', "result");
arrayfile::arrayfilemode_t mode = arrayfile_t::parseModeString (opt->getStringValue ('f', "T"));
OAextend oaextend;
oaextend.setAlgorithm (algorithm);
if (streaming) {
logstream (SYSTEM) << "operating in streaming mode, sorting of arrays will not work "
<< std::endl;
oaextend.extendarraymode = OAextend::STOREARRAY;
}
// J5_45
int xx = opt->getFlag ('x');
if (xx) {
oaextend.j5structure = J5_45;
}
if (userowsymm == 0) {
oaextend.use_row_symmetry = userowsymm;
printf ("use row symmetry -> %d\n", oaextend.use_row_symmetry);
}
if (opt->getFlag ('g')) {
std::cout << "only generating arrays (no LMC check)" << endl;
oaextend.checkarrays = 0;
}
if (opt->getFlag ("help") || (opt->getValue ("coptions") != NULL)) {
if (opt->getFlag ("help")) {
opt->printUsage ();
}
if (opt->getValue ("coptions") != NULL) {
print_options (cout);
}
} else {
logstream (QUIET) << "#time start: " << currenttime () << std::endl;
arraydata_t *ad;
ad = readConfigFile (oaconfigfile);
ad->lmc_overflow_check ();
if (ad == 0) {
return 1;
}
log_print (NORMAL, "Using design file: %s (runs %d, strength %d)\n", oaconfigfile, ad->N,
ad->strength);
if (oaextend.getAlgorithm () == MODE_AUTOSELECT) {
oaextend.setAlgorithmAuto (ad);
}
#ifdef OAEXTEND_SINGLECORE
if (initcolprev == 0) {
log_print (NORMAL, "setting oaextend.init_column_previous to %d\n", INITCOLUMN_ZERO);
oaextend.init_column_previous = INITCOLUMN_ZERO;
}
#endif
#ifdef OAEXTEND_MULTICORE
int alg = oaextend.getAlgorithm ();
for (int i = 0; i < n_processors; i++) {
if (i == MASTER) {
continue;
}
log_print (NORMAL, "MASTER: sending algorithm %d to slave %d\n", alg, i);
send_int (alg, i);
}
#endif
colindex_t col_start;
log_print (SYSTEM, "using algorithm %d (%s)\n", oaextend.getAlgorithm (),
oaextend.getAlgorithmName ().c_str ());
if (log_print (NORMAL, "")) {
cout << oaextend.__repr__ ();
}
if (restart) { // start from result file
int initres = init_restart (opt->getValue ('r'), col_start, solutions);
if (initres == 1) { // check if restarting went OK
logstream (SYSTEM) << "Problem with restart from " << opt->getValue ('r') << ""
<< endl;
#ifdef OAEXTEND_MPI
MPI_Abort (MPI_COMM_WORLD, 1);
#endif
exit (1);
}
if (dosort) {
double Ttmp = get_time_ms ();
sort (solutions.begin (), solutions.end ()); // solutions.sort();
log_print (QUIET, " sorting of initial solutions: %.3f [s]\n",
get_time_ms () - Ttmp);
}
// check that oaconfig agrees with loaded arrays
if (solutions.size () > 0) {
if (ad->N != solutions[0].n_rows) {
printf ("Problem: oaconfig does not agree with loaded arrays!\n");
// free_sols(solutions); ??
solutions.clear ();
}
}
} else {
// starting with root
if (check_divisibility (ad) == false) {
log_print (SYSTEM, "ERROR: Failed divisibility test!\n");
#ifdef OAEXTEND_MPI
MPI_Abort (MPI_COMM_WORLD, 1);
#endif
exit (1);
}
create_root (ad, solutions);
col_start = ad->strength;
}
/*-----------MAIN EXTENSION LOOP-------------*/
log_print (SYSTEM, "M: running with %d procs\n", n_processors);
maxk = std::min (maxk, ad->ncols);
time_t seconds;
for (colindex_t current_col = col_start; current_col < maxk; current_col++) {
fflush (stdout);
arraydata_t *adcol = new arraydata_t (ad, current_col + 1);
if (streaming) {
string fname = resultprefix;
fname += "-streaming";
fname += "-" + oafilestring (ad);
logstream (NORMAL) << "oaextend: streaming mode: create file " << fname
<< std::endl;
int nb = arrayfile_t::arrayNbits (*ad);
oaextend.storefile.createfile (fname, adcol->N, ad->ncols, -1, ABINARY, nb);
}
log_print (SYSTEM, "Starting with column %d (%d, total time: %.2f [s])\n",
current_col + 1, (int)solutions.size (), get_time_ms () - Tstart);
nr_extensions = 0;
arraylist_t::const_iterator cur_extension;
int csol = 0;
for (cur_extension = solutions.begin (); cur_extension != solutions.end ();
cur_extension++) {
print_progress (csol, solutions, extensions, Tstart, current_col);
logstream (NORMAL) << cur_extension[0];
if (n_processors == 1) {
nr_extensions += extend_array (*cur_extension, adcol,
current_col, extensions, oaextend);
} else {
#ifdef OAEXTEND_MPI
throw_runtime_exception("mpi version of oextend is no longer supported");
double Ttmp = get_time_ms ();
int slave = collect_solutions_single (extensions, adcol);
log_print (DEBUG, " time: %.2f, collect time %.2f\n",
(get_time_ms () - Tstart), (get_time_ms () - Ttmp));
/* OPTIMIZE: send multiple arrays to slave 1 once step */
extend_array_mpi (cur_extension->array, 1, adcol, current_col, slave);
#endif
}
#ifdef OAEXTEND_MPI
if ((csol + 1) % nsolsync == 0) {
collect_solutions_all (extensions, adcol);
}
#endif
// OPTIMIZE: periodically write part of the solutions to disk
csol++; /* increase current solution */
}
#ifdef OAEXTEND_MPI
collect_solutions_all (extensions, adcol);
#endif
if (checkloglevel (NORMAL)) {
csol = 0;
for (cur_extension = extensions.begin (); cur_extension != extensions.end ();
cur_extension++) {
log_print (DEBUG, "%i: -----\n", ++csol);
logstream (DEBUG) << cur_extension[0];
}
}
if (dosort) {
log_print (DEBUG, "Sorting solutions, necessary for multi-processor code\n");
double Ttmp = get_time_ms ();
sort (extensions.begin (), extensions.end ());
log_print (DEBUG, " sorting time: %.3f [s]\n", get_time_ms () - Ttmp);
}
save_arrays (extensions, adcol, resultprefix, mode);
solutions.swap (extensions); // swap old and newly found solutions
extensions.clear (); // clear old to free up space for new extensions
log_print (SYSTEM, "Done with column %i, total of %i solutions (time %.2f s))\n",
current_col + 1, (int)solutions.size (), get_time_ms () - Tstart);
delete adcol;
#ifdef OAANALYZE_DISCR
logstream (NORMAL) << "Discriminant: " << endl;
print_discriminant (ad->N, current_col + 1);
#endif
}
/*------------------------*/
time (&seconds);
struct tm *tminfo;
tminfo = localtime (&seconds);
log_print (SYSTEM, "TIME: %.2f s, %s", get_time_ms () - Tstart, asctime (tminfo));
logstream (QUIET) << "#time end: " << currenttime () << std::endl;
logstream (QUIET) << "#time total: " << printfstring ("%.1f", get_time_ms () - Tstart)
<< " [s]" << std::endl;
solutions.clear ();
delete ad;
#ifdef OAEXTEND_MPI
stop_slaves ();
#endif
}
delete opt;
} /* end of master code */
#ifdef OAEXTEND_MPI
MPI_Finalize ();
#endif
return 0;
}
/**
* @brief Filter arrays in a file and write filtered arrays to output file
* @param argc Number of command line arguments
* @param argv Command line arguments
* @return
*/
int main (int argc, char *argv[]) {
AnyOption opt;
/* parse command line options */
opt.setFlag ("help", 'h'); /* a flag (takes no argument), supporting long and short form */
opt.setOption ("output", 'o');
opt.setOption ("verbose", 'v');
opt.setOption ("na", 'a');
opt.setOption ("index", 'i');
opt.setOption ("format", 'f');
opt.addUsage ("Orthonal Array Filter: filter arrays");
opt.addUsage ("Usage: oaanalyse [OPTIONS] [INPUTFILE] [VALUESFILE] [THRESHOLD] [OUTPUTFILE]");
opt.addUsage (" The VALUESFILE is a binary file with k*N double values. Here N is the number of arrays");
opt.addUsage (" and k the number of analysis values.");
opt.addUsage ("");
opt.addUsage (" -h --help Prints this help ");
opt.addUsage (" -v --verbose Verbose level (default: 1) ");
opt.addUsage (" -a Number of values in analysis file (default: 1) ");
opt.addUsage (" --index Index of value to compare (default: 0) ");
opt.addUsage (" -f [FORMAT] Output format (default: TEXT, or BINARY; B) ");
opt.processCommandArgs (argc, argv);
print_copyright ();
/* parse options */
if (opt.getFlag ("help") || opt.getFlag ('h') || opt.getArgc () < 4) {
opt.printUsage ();
exit (0);
}
int verbose = opt.getIntValue ('v', 1);
int na = opt.getIntValue ('a', 1);
int index = opt.getIntValue ("index", 0);
std::string format = opt.getStringValue ('f', "BINARY");
arrayfile::arrayfilemode_t mode = arrayfile_t::parseModeString (format);
/* read in the arrays */
std::string infile = opt.getArgv (0);
std::string anafile = opt.getArgv (1);
double threshold = atof (opt.getArgv (2));
std::string outfile = opt.getArgv (3);
if (verbose)
printf ("oafilter: input %s, threshold %f (analysisfile %d values, index %d)\n", infile.c_str (),
threshold, na, index);
arraylist_t *arraylist = new arraylist_t;
int n = readarrayfile (opt.getArgv (0), arraylist);
if (verbose)
printf ("oafilter: filtering %d arrays\n", n);
// read analysis file
FILE *afid = fopen (anafile.c_str (), "rb");
if (afid == 0) {
printf (" could not read analysisfile %s\n", anafile.c_str ());
exit (0);
}
double *a = new double[n * na];
fread (a, sizeof (double), n * na, afid);
fclose (afid);
std::vector< int > gidx;
;
for (int jj = 0; jj < n; jj++) {
double val = a[jj * na + index];
if (val >= threshold)
gidx.push_back (jj);
if (verbose >= 2)
printf ("jj %d: val %f, threshold %f\n", val >= threshold, val, threshold);
}
// filter
arraylist_t *filtered = new arraylist_t;
selectArrays (*arraylist, gidx, *filtered);
/* write arrays to file */
if (verbose)
cout << "Writing " << filtered->size () << " arrays (input " << arraylist->size () << ") to file "
<< outfile << endl;
writearrayfile (outfile.c_str (), *filtered, mode);
/* free allocated structures */
delete[] a;
delete arraylist;
delete filtered;
return 0;
}
