18 #include <sys/times.h>
25 printf(
"%s size (%3zu) : ", _set_name, _set.size());
30 typename set<T>::const_iterator range_begin = _set.begin();
31 typename set<T>::const_iterator range_end = range_begin;
32 typename set<T>::const_iterator it = _set.begin();
36 if (*it == (*range_end)+1) {
40 if (range_end == range_begin) {
41 cout << *range_begin <<
" ";
44 cout << *range_begin <<
"-" << *range_end <<
" ";
51 if (range_end != range_begin) cout <<
"-" << *range_end;
53 if (_cr_at_end) cout <<
"\n";
58 template<
class T1,
class T2>
59 void PS_print_map_ranges(
const char *_map_name,
const map<T1, T2> &_map,
const bool _compare_keys =
true,
const bool _cr_at_end =
true) {
62 printf(
"%s size ( 0) : (empty)", _map_name);
66 printf(
"%s size (%3i) : ", _map_name, _map.size());
67 typename map<T1, T2>::const_iterator range_begin = _map.begin();
68 typename map<T1, T2>::const_iterator range_end = range_begin;
69 typename map<T1, T2>::const_iterator it = _map.begin();
73 if (it->first == range_end->first+1) {
77 if (range_end == range_begin) {
78 cout <<
"(" << range_begin->first <<
"," << range_begin->second <<
") ";
81 cout <<
"(" << range_begin->first <<
"-" << range_end->first <<
"," << range_begin->second <<
") ";
87 if (range_end == range_begin) {
88 cout <<
"(" << range_begin->first <<
"," << range_begin->second <<
") ";
91 cout <<
"(" << range_begin->first <<
"-" << range_end->first <<
"," << range_begin->second <<
") ";
95 map<T2, set<pair<T1, T1> > > value2indices;
96 map<T2, unsigned long int> value2count;
98 range.first = _map.begin()->first;
99 range.second = range.first;
100 T2 cur_value = _map.begin()->second;
101 typename map<T1, T2>::const_iterator it = _map.begin();
105 if (it->second == cur_value) {
106 if (it->first == range.second+1) {
107 range.second = it->first;
110 value2indices[cur_value].insert(range);
111 value2count[cur_value] += range.second - range.first + 1;
112 range.first = it->first;
113 range.second = it->first;
117 value2indices[cur_value].insert(range);
118 value2count[cur_value] += range.second - range.first + 1;
119 range.first = it->first;
120 range.second = it->first;
121 cur_value = it->second;
124 value2indices[cur_value].insert(range);
125 value2count[cur_value] += range.second - range.first + 1;
126 for (
typename map<T2, set<pair<T1, T1> > >::const_iterator value = value2indices.begin();
127 value != value2indices.end();
129 if (value != value2indices.begin()) cout <<
"\n";
130 printf(
"%s size (%3i) : value (", _map_name, _map.size());
131 cout << value->first <<
") count (" << value2count[value->first] <<
") [";
132 for (
typename set<pair<T1, T1> >::const_iterator indices = value->second.begin();
133 indices != value->second.end();
135 if (indices != value->second.begin()) cout <<
" ";
136 cout << indices->first;
137 if (indices->first != indices->second) cout <<
"-" << indices->second;
139 cout <<
"]," << value->first <<
")";
143 if (_cr_at_end) cout <<
"\n";
170 #define __THRESHOLD_PERCENTAGE_NEXT_SOURCE_ID_SET 5
173 #define __THRESHOLD_PERCENTAGE_NEXT_TARGET_ID_SET 95
186 #define __MIN_PERCENTAGE_SET_MATCH 40
187 #define __MAX_PERCENTAGE_SET_MATCH 60
223 unsigned long int gain = 0;
225 for (
SpeciesID not_in_path_ID = __MIN_ID;
228 if (not_in_path_ID == next_path_ID) {
230 next_path_ID = (path_iter ==
__PATH.end()) ? -1 : *path_iter;
237 if (not_in_path_ID == *path_ID)
239 if (not_in_path_ID > *path_ID) {
240 gain += !_map->get(not_in_path_ID, *path_ID);
243 gain += !_map->get(*path_ID, not_in_path_ID);
249 for (
SpeciesID not_in_path_ID = __MIN_ID;
252 if (not_in_path_ID == next_path_ID) {
254 next_path_ID = (path_iter ==
__PATH.end()) ? -1 : *path_iter;
261 if (not_in_path_ID == *path_ID)
263 if (not_in_path_ID > *path_ID) {
264 gain += !
__MAP->get(not_in_path_ID, *path_ID);
267 gain += !
__MAP->get(*path_ID, not_in_path_ID);
272 if (_filling_level) {
273 unsigned long int trues = (_map) ? _map->getCountOfTrues() + gain :
__MAP->getCountOfTrues() + gain;
281 long count_matched_source = 0;
282 long count_matched_target = 0;
288 PS_BitSet::IndexSet::const_iterator target_end =
__TARGET_ID_SET.end();
291 while (path != path_end) {
293 while ((*target < path_id) && (target != target_end)) {
296 if ((target != target_end) && (*target == path_id))
297 ++count_matched_target;
298 while ((*source < path_id) && (source != source_end)) {
301 if ((source != source_end) && (*source == path_id))
302 ++count_matched_source;
331 if ((
id >= __MIN_SETS_ID) && has_probes && !_candidate_parent->
alreadyUsedNode(_ps_node)) {
338 float distance_to_perfect_match;
341 int status = (gain < (unsigned)__SPECIES_COUNT / 100)
343 : _candidate_parent->
addChild(static_cast<unsigned long>(distance_to_perfect_match), gain, _ps_node,
__PATH);
361 if ((
id < __MAX_SETS_ID) || (! has_probes)) {
392 (i != _root_node->
getChildrenEnd()) && (i->first < __MAX_SETS_ID);
403 c != _candidate_parent->
children.end();
405 printf(
"PS_find_probes(%i) : ", _round);
430 count =
__MAP->getCountFor(
id);
431 if (count == __SPECIES_COUNT-__MIN_ID-1)
continue;
432 if (count > highest_count) highest_count = count;
433 if (count < lowest_count) lowest_count = count;
436 printf(
"PS_calc_next_speciesid_sets() : SOURCE count 1's [%i..%i] threshold (%.3f)", lowest_count, highest_count, threshold);
454 unsigned long count_iterations = 0;
457 ++source_id, ++count_iterations) {
461 for (PS_BitSet::IndexSet::iterator target_id =
__TARGET_ID_SET.begin();
464 if ((*target_id < __MIN_ID) || (*target_id >
__MAX_ID))
continue;
465 if (*target_id != *source_id) ++count_falses_per_id[*target_id];
472 for (
ID2IDMapCIter count_per_id = count_falses_per_id.begin();
473 count_per_id != count_falses_per_id.end();
475 if (count_per_id->second > highest_count) highest_count = count_per_id->second;
476 if (count_per_id->second < lowest_count) lowest_count = count_per_id->second;
478 printf(
"PS_calc_next_speciesid_sets() : TARGET count 0's [%i..%i]", lowest_count, highest_count);
482 for (
ID2IDMapCIter count_per_id = count_falses_per_id.begin();
483 count_per_id != count_falses_per_id.end();
485 if (count_per_id->second == highest_count)
__TARGET_ID_SET.insert(count_per_id->first);
496 unsigned long int gain = 0;
498 for (
SpeciesID not_in_path_ID = __MIN_ID;
501 if (not_in_path_ID == next_path_ID) {
503 next_path_ID = (path_iter == _path.end()) ? -1 : *path_iter;
508 path_ID != _path.end();
510 if (not_in_path_ID == *path_ID)
continue;
511 if (not_in_path_ID > *path_ID) {
512 gain += !_map->set(not_in_path_ID, *path_ID,
true);
515 gain += !_map->set(*path_ID, not_in_path_ID,
true);
521 for (
SpeciesID not_in_path_ID = __MIN_ID;
524 if (not_in_path_ID == next_path_ID) {
526 next_path_ID = (path_iter == _path.end()) ? -1 : *path_iter;
531 path_ID != _path.end();
533 if (not_in_path_ID == *path_ID)
continue;
534 if (not_in_path_ID > *path_ID) {
535 gain += !
__MAP->set(not_in_path_ID, *path_ID,
true);
538 gain += !
__MAP->set(*path_ID, not_in_path_ID,
true);
543 unsigned long int sets = (__SPECIES_COUNT-_path.size())*_path.size();
544 if (!_silent) printf(
"PS_apply_path_to_bitmap() : gain %lu of %lu -- %.2f%% -> wasted %lu\n", gain, sets, ((
float)gain/sets)*100.0, sets-gain);
550 unsigned long trues =
__MAP->getCountOfTrues();
553 _candidate->filling_level = percentage;
557 printf(
"PS_filling_level() : bitmap (%lu) now has %lu trues and %lu falses -- %.5f%% filled\n",
__BITS_IN_MAP, trues,
__BITS_IN_MAP-trues, percentage);
565 char *
buffer = (
char *)malloc(4096);
567 sprintf(buffer,
"%s.%06li", _out_prefix, _iteration);
568 char *data_name = strdup(buffer);
571 long size = sprintf(buffer,
"# CANDIDATE #%li path (%zu)\n", _iteration, _path.size());
572 file->
put(buffer, size);
576 size = sprintf(buffer,
"# %i\n", *i);
577 file->
put(buffer, size);
579 size = sprintf(buffer,
"#noMatches (%zu)\n", _noMatches.size());
580 file->
put(buffer, size);
582 p != _noMatches.end();
584 size = sprintf(buffer,
"%i %i\n", p->first, p->second);
585 file->
put(buffer, size);
587 size = sprintf(buffer,
"\n\n");
588 file->
put(buffer, size);
589 sprintf(buffer,
"Bitmap after %li. candidate", _iteration);
590 char *
title = strdup(buffer);
591 __MAP->printGNUplot(title, buffer, file);
593 sprintf(buffer,
"%s.%06li.gnuplot", _out_prefix, _iteration);
596 size = sprintf(buffer,
"set terminal png color\nset output '%06li.bitmap.png\n", _iteration);
597 file->
put(buffer, size);
598 size = sprintf(buffer,
"set yrange [%i:%i] reverse\nset xrange [%i:%i]\n", __MIN_ID, __MAX_ID, __MIN_ID, __MAX_ID);
599 file->
put(buffer, size);
600 size = sprintf(buffer,
"set size square\nset title '%li. iteration'\nset pointsize 0.5\n", _iteration);
601 file->
put(buffer, size);
602 size = sprintf(buffer,
"plot '%s' index 1 title 'match ()' with dots 2,'%s' index 0 title 'no match (30)' with points 1\n", data_name, data_name);
603 file->
put(buffer, size);
604 size = sprintf(buffer,
"set terminal png color\nset output '%06li.counters.png\n", _iteration);
605 file->
put(buffer, size);
606 size = sprintf(buffer,
"set yrange [] noreverse\nset size nosquare\n");
607 file->
put(buffer, size);
608 size = sprintf(buffer,
"plot '%s' index 2 title 'count/species' with impulses 2,'%s' index 3 title 'species/count' with points 1", data_name, data_name);
609 file->
put(buffer, size);
629 while (parent && !parent->
path.empty()) {
638 return _last_candidate->
parent;
646 printf(
"\nDESCEND ==================== depth (%lu / %lu) candidates (%lu / %lu -> %lu left) ====================\n",
652 printf(
"DESCEND PATH : (%s)\n\n", __PATH_IN_CANDIDATES);
658 printf(
"\nDESCEND ---------- calculated next speciesid-sets ----------\n\n");
fflush(stdout);
665 for (; round<3 && _candidate_parent->
children.empty(); ++round) {
666 PS_find_probes(_root_node, round, _candidate_parent, _filling_level);
668 printf(
"\nDESCEND ---------- searched probe for speciesid-sets [rounds : %i] candidates (%lu / %lu -> %lu left) ----------\n\n",
677 char count =
'0'+_candidate_parent->
children.size();
679 next_candidate_it != _candidate_parent->
children.rend();
680 ++next_candidate_it, --count) {
686 printf(
"[%p] ", next_candidate);
688 printf(
"[%p] ", next_candidate);
690 next_candidate->
depth = _depth+1;
691 next_candidate->
print(0,
false,
false);
696 __PATH_IN_CANDIDATES[_depth] = count;
697 __PATH_IN_CANDIDATES[_depth+1] =
'\x00';
706 printf(
"\nDESCEND ~~~~~~~~~~~~~~~~~~~~ depth (%li) max depth (%li) candidates (%lu / %lu -> %lu left) ~~~~~~~~~~~~~~~~~~~~ ",
713 printf(
"\n");
fflush(stdout);
719 if (_candidate->
map)
return;
720 _candidate->
map =
new PS_BitMap_Counted(
false, __MAX_ID+1);
724 while (parent && !parent->
path.empty()) {
733 const bool _ignore_passes_left =
false) {
736 next_candidate != _candidate_parent->
children.end();
739 if ((next_candidate->second->children.size() == 0) &&
740 ((next_candidate->second->passes_left > 0) || _ignore_passes_left)) {
741 _leaf_candidates.insert(next_candidate->second);
762 if ((
id >= __MIN_SETS_ID) && has_probes) {
763 unsigned long total_gain_of_node = 0;
764 unsigned long total_tests_per_node = 0;
768 candidate_iter != _leaf_candidates.end();
773 if (candidate->alreadyUsedNode(_ps_node))
continue;
776 if (
__VERBOSE) printf(
"%8lup %8lur %8luc %8lug %8luu\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
784 unsigned long matches = candidate->matchPathOnOneFalseIDs(
__PATH);
785 if (matches < candidate->one_false_IDs_matches)
continue;
788 if (
__VERBOSE) printf(
"%8lup %8lur %8luc %8lug %8luu\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
797 ++total_tests_per_node;
799 total_gain_of_node += gain;
800 if (candidate->updateBestChild(gain, matches, filling_level, _ps_node,
__PATH)) {
802 if (
__VERBOSE) printf(
"%8lup %8lur %8luc %8lug %8luu\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
810 if ((total_tests_per_node == _leaf_candidates.size()) &&
811 (total_gain_of_node == 0)) {
813 if (
__VERBOSE) printf(
"%8lup %8lur %8luc %8lug %8luu\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
827 if ((
id < __MAX_SETS_ID) || (! has_probes)) {
846 printf(
"PS_get_next_candidates() : initializing %zu candidates..\n", _leaf_candidates.size());
fflush(stdout);
855 iter != _leaf_candidates.end();
858 if (!candidate->map) {
859 candidate->getParentMap();
860 if (candidate->map) {
865 candidate->initFalseIDs(__MIN_ID, __MAX_ID, __MIN_SETS_ID, __MAX_SETS_ID);
868 printf(
"PS_get_next_candidates() : ");
fflush(stdout);
870 (node_iter != _root_node->
getChildrenEnd()) && (node_iter->first < __MAX_SETS_ID);
875 printf(
"looked at probes (%lu) -> removed probes (%lu) possible candidates (%lu) -> good candidates (%lu) -> used candidates (%lu)\nPS_get_next_candidates() : ",
885 iter != _leaf_candidates.end();
889 candidate->decreasePasses();
892 _leaf_candidates.clear();
904 printf(
"Missing argument\n Usage %s <database name> <result filename> <[-]candidates filename> <final candidates filename> [--verbose] [result filename prefix for output files]\n", argv[0]);
908 const char *input_DB_name = argv[1];
909 const char *result_in_filename = argv[2];
910 const char *candidates_filename = argv[3];
911 const char *final_candidates_filename = argv[4];
912 const char *result_out_prefix = (argc > 5) ? argv[5] :
NULp;
914 if (strcmp(result_out_prefix,
"--verbose") == 0) {
916 result_out_prefix = (argc > 6) ? argv[6] :
NULp;
922 printf(
"Opening probe-set-database '%s'..\n", input_DB_name);
923 PS_Database *db =
new PS_Database(input_DB_name, PS_Database::READONLY);
925 __MAX_ID = db->getMaxID();
926 __MIN_ID = db->getMinID();
927 __SPECIES_COUNT = db->getSpeciesCount();
928 printf(
"min ID (%i) max ID (%i) count of species (%i)\n", __MIN_ID, __MAX_ID, __SPECIES_COUNT);
929 printf(
"..loaded database (enter to continue)\n");
fflush(stdout);
934 printf(
"Opening result file %s..\n", result_in_filename);
939 printf(
"reading no matches : ");
941 printf(
"(%li)\n", size);
fflush(stdout);
947 printf(
" %i,%i", id1, id2);
955 printf(
"\nreading one matches : ");
957 printf(
"(%li)\n", size);
fflush(stdout);
969 printf(
"%i,%i path(%li)", id1, id2, path_length);
970 while (path_length-- > 0) {
972 printf(
" %i", path_id);
973 path.insert(path_id);
978 printf(
"loading preset bitmap..\n");
fflush(stdout);
980 __MAP =
new PS_BitMap_Counted(result_file);
981 __PRESET_MAP =
new PS_BitMap_Counted(
false, __MAX_ID+1);
982 for (id1 = 0; id1 <
__MIN_ID; ++id1) {
983 for (id2 = 0; id2 <=
__MAX_ID; ++id2) {
985 __MAP->setTrue(id1, id2);
988 __MAP->setTrue(id2, id1);
993 __MAP->setTrue(
id,
id);
995 __MAP->recalcCounters();
997 printf(
"..loaded result file (enter to continue)\n");
998 printf(
"cleaning up... result file\n");
fflush(stdout);
1007 if (candidates_filename[0] !=
'-') {
1008 printf(
"searching candidates..\n");
1013 for (
long species_count = __SPECIES_COUNT; species_count > 0; species_count >>= 1) {
1017 __PATH_IN_CANDIDATES = (
char *)calloc(
__MAX_DEPTH+1,
sizeof(
char));
1021 PS_descend(__CANDIDATES_ROOT, db->getConstRootNode(), 0, 0.0);
1022 printf(
"PS_descend : total ");
1028 printf(
"saving candidates to %s..\n", candidates_filename);
1034 printf(
"loading candidates..\n");
1036 __CANDIDATES_ROOT->
load(candidates_file,
__BITS_IN_MAP, db->getConstRootNode());
1037 printf(
"..loaded candidates file (enter to continue)\n");
1039 printf(
"cleaning up... candidates file\n");
fflush(stdout);
1040 delete candidates_file;
1045 printf(
"CANDIDATES :\n");
1046 __CANDIDATES_ROOT->
print();
1047 printf(
"\nsearching leaf candidates.. ");
1050 printf(
"%zu\n", leaf_candidates.size());
1057 while (!leaf_candidates.empty() && round<200) {
1058 printf(
"\nsearching next candidates [round #%li]..\n", ++round);
1061 printf(
"rounds %li total ", round);
1065 printf(
"\nFINAL CANDIDATES:\n");
1066 __CANDIDATES_ROOT->
print(0,
true);
1067 printf(
"\nfinal leaf candidates.. (%zu)\n", leaf_candidates.size());
1070 c != leaf_candidates.end();
1078 printf(
"saving final candidates to %s..\n", final_candidates_filename);
1081 printf(
"cleaning up... candidates file\n");
fflush(stdout);
1082 delete candidates_file;
1088 if (result_out_prefix) {
1094 while (best_candidate) {
1096 best_candidate =
PS_ascend(best_candidate);
1103 printf(
"cleaning up... candidates\n");
fflush(stdout);
1105 free(__PATH_IN_CANDIDATES);
1106 printf(
"cleaning up... database\n");
fflush(stdout);
1108 printf(
"cleaning up... bitmaps\n");
fflush(stdout);
static unsigned long __CANDIDATES_TODO
static const bool READONLY
static unsigned long __CANDIDATES_FINISHED
static void PS_find_probes(const PS_NodePtr &_root_node, const int _round, PS_CandidatePtr _candidate_parent, const float _filling_level)
PS_NodeMapIterator getChildrenBegin()
PS_CandidateSet::iterator PS_CandidateSetIter
int main(int argc, char *argv[])
static float __TARGET_MIN_MATCH_COUNT
void PS_apply_path_to_bitmap(IDSet &_path, const bool _silent=false, PS_BitMap_Counted *_map=NULp)
static unsigned long __BITS_IN_MAP
std::set< SpeciesID > IDSet
static bool PS_test_sets_on_path(float &_distance)
static PS_BitSet::IndexSet __TARGET_ID_SET
bool alreadyUsedNode(const PS_NodePtr &_ps_node) const
#define __THRESHOLD_PERCENTAGE_NEXT_SOURCE_ID_SET
#define __MAX_PERCENTAGE_SET_MATCH
void get_long(long int &_l)
static void PS_make_map_for_candidate(PS_CandidatePtr _candidate)
void PS_get_next_candidates(const PS_NodePtr &_root_node, PS_CandidateSet &_leaf_candidates)
static float __SOURCE_MAX_MATCH_COUNT
PS_NodeMap::const_iterator PS_NodeMapConstIterator
ID2IDMap::const_iterator ID2IDMapCIter
static unsigned long __MAX_DEPTH
char buffer[MESSAGE_BUFFERSIZE]
static float PS_filling_level(PS_CandidatePtr _candidate=NULp)
static PS_BitMap_Counted * __PRESET_MAP
std::map< SpeciesID, SpeciesID > ID2IDMap
static IDSet __SOURCE_ID_SET
static PS_CandidatePtr __CANDIDATES_ROOT
PS_NodeMapIterator getChildrenEnd()
set< PS_CandidateSPtr, cmp_candidates > PS_CandidateSet
void PS_print_set_ranges(const char *_set_name, const set< T > &_set, const bool _cr_at_end=true)
PS_CandidateByGainMap::iterator PS_CandidateByGainMapIter
void PS_GNUPlot(const char *_out_prefix, const long _iteration, const IDSet &_path, const ID2IDSet &_noMatches)
PS_CandidateByGainMap children
static unsigned long __PROBES_COUNTER
static float __TARGET_MAX_MATCH_COUNT
static SpeciesID __MIN_SETS_ID
static SpeciesID __MAX_ID
void put(const void *_data, int _length)
static void PS_calc_next_speciesid_sets()
static void PS_descend(PS_CandidatePtr _candidate_parent, const PS_NodePtr &_root_node, unsigned long _depth, const float _filling_level)
static PS_BitMap_Counted * __MAP
static float __SOURCE_PERFECT_MATCH_COUNT
std::set< ID2IDPair > ID2IDSet
static BasicStatus status
PS_CandidateByGainMap::reverse_iterator PS_CandidateByGainMapRIter
static SpeciesID __SPECIES_COUNT
ID2IDSet::const_iterator ID2IDSetCIter
static SpeciesID __MIN_ID
void PS_get_leaf_candidates(PS_CandidatePtr _candidate_parent, PS_CandidateSet &_leaf_candidates, const bool _ignore_passes_left=false)
static unsigned long __CANDIDATES_COUNTER
void reduceChildren(const float _filling_level)
static unsigned long __PROBES_REMOVED
int addChild(unsigned long _distance, unsigned long _gain, const PS_NodePtr &_node, IDSet &_path)
#define __MIN_PERCENTAGE_SET_MATCH
static unsigned long int PS_test_candidate_on_bitmap(float *_filling_level=NULp, PS_BitMap_Counted *_map=NULp)
void PS_print_map_ranges(const char *_map_name, const map< T1, T2 > &_map, const bool _compare_keys=true, const bool _cr_at_end=true)
static void PS_find_probe_for_sets(const PS_NodePtr &_ps_node, PS_CandidatePtr _candidate_parent)
static float __SOURCE_MIN_MATCH_COUNT
void load(PS_FileBuffer *_file, const unsigned long _bits_in_map, const PS_NodePtr &_root_node)
PS_CandidateByGainMap::const_iterator PS_CandidateByGainMapCIter
void PS_get_next_candidates_descend(PS_NodePtr _ps_node, PS_CandidateSet &_leaf_candidates)
static float __TARGET_PERFECT_MATCH_COUNT
void print(const unsigned long _depth=0, const bool _print_one_false_IDs=false, const bool _descend=true) const
std::pair< SpeciesID, SpeciesID > ID2IDPair
static char * __PATH_IN_CANDIDATES
void reinit(const char *name, bool _readonly)
void save(PS_FileBuffer *_file, const unsigned long _bits_in_map)
static const bool WRITEONLY
static SpeciesID __MAX_SETS_ID
static PS_CandidatePtr PS_ascend(PS_CandidatePtr _last_candidate)
IDSet::const_iterator IDSetCIter