//! Prefix increment of the iterator.
iterator& operator++()
{
if (!m_valid) return *this;
if (m_v == m_cst->root() and m_visited) {
m_valid = false;
return *this;
}
value_type w;
if (!m_visited) { // go down, if possible
if (m_cst->is_leaf(m_v)) {
w = m_cst->sibling(m_v); // determine sibling of leaf v
if (w == m_cst->root()) { // if there exists no right sibling of the leaf v
// w = m_cst->parent(m_v);
w = parent();
m_visited = true; // go up
}
} else { // v is not a leaf => go down the tree
w = first_child();
}
} else { //
w = m_cst->sibling(m_v);
if (w == m_cst->root()) { // if there exists no right sibling
w = parent();
} else {
m_visited = false;
}
}
m_v = w;
return *this;
}
//! Prefix increment of the iterator.
iterator& operator++()
{
if (!m_valid) return *this;
if (m_v == m_cst->root()) {
m_valid = false;
return *this;
}
value_type w = m_cst->sibling(m_v);
if (w == m_cst->root()) { // if no next right sibling exist
m_v = m_cst->parent(m_v); // go to parent
} else { // if next right sibling exist
m_v = m_cst->leftmost_leaf(w); // go to leaftmost leaf in the subtree of w
}
return *this;
}
void test_cst_child_operation(const Cst& cst, typename Cst::size_type times=5000, uint64_t x=17)
{
typedef typename Cst::size_type size_type;
typedef typename Cst::node_type node_type;
std::vector<node_type> nodes;
generate_nodes_from_random_leaves(cst, times, nodes, x);
// for(size_type i=0; i<20; ++i){
// std::cout<< cst.lb(nodes[i])<<" "<<cst.rb(nodes[i])<<std::endl;
// }
// choose some chars for the text
unsigned char* letters = new unsigned char[nodes.size()+1];
for (size_type i=0; i<nodes.size(); ++i) {
letters[i] = cst.csa.bwt[i];
}
node_type c; // for child node
size_type char_pos=0;
size_type cnt=0;
write_R_output("cst","child","begin",nodes.size(),cnt);
for (size_type i=0; i<nodes.size(); ++i) {
// if(i<20){
// std::cout<<"i="<<i<<" vl="<<cst.lb(nodes[i])<<" rb="<<cst.rb(nodes[i])<<std::endl;
// std::cout<<cst.csa[cst.lb(nodes[i])]<<" "<<cst.depth(nodes[i])<<std::endl;
// }
c = cst.child(nodes[i], letters[i], char_pos);
if (c==cst.root())
++cnt;
}
write_R_output("cst","child","end",nodes.size(),cnt);
delete [] letters;
}
void test_cst_parent_operation(const Cst& cst, typename Cst::size_type times=100000, uint64_t x=17)
{
typedef typename Cst::size_type size_type;
typedef typename Cst::node_type node_type;
srand(x);
size_type n = cst.csa.size();
// take \f$ time \f$ random leaves
std::vector<node_type> rand_leaf(times);
for (size_type i=0; i<rand_leaf.size(); ++i) {
rand_leaf[i] = cst.select_leaf(1+ (rand() % n));
}
node_type p;
size_type cnt=0;
write_R_output("cst","parent","begin",times,cnt);
for (size_type i=0; i<times; ++i, ++cnt) {
p = cst.parent(rand_leaf[i]);
while (p != cst.root()) {
p = cst.parent(p);
++cnt;
}
}
write_R_output("cst","parent","end",times,cnt);
}
//! Constructor
cst_dfs_const_forward_iterator(const Cst* cst, const value_type node, bool visited=false, bool valid=true):m_visited(visited), m_valid(valid), m_stack_cache(nullptr) {
m_cst = cst;
m_v = node;
if (m_cst == nullptr) {
m_valid = false;
} else if (m_v == m_cst->root() and !m_visited and m_valid) { // if the iterator equal cst.begin()
m_stack_cache = new node_type[cache_size];
m_stack_size = 0;
// std::cerr<<"#creating stack "<<m_cst->lb(m_v)<<" "<<m_cst->rb(m_v)<<std::endl;
}
}
//! Prefix increment of the iterator.
iterator& operator++()
{
if (!m_valid) return *this;
if (m_queue.empty()) {
m_valid = false;
return *this;
}
value_type v = m_queue.front();
m_queue.pop();
value_type child = m_cst->select_child(v, 1);
while (m_cst->root() != child) {
m_queue.push(child);
child = m_cst->sibling(child);
}
return *this;
}
void generate_nodes_from_random_leaves(const Cst& cst, typename Cst::size_type times, std::vector<typename Cst::node_type>& nodes, uint64_t x=17)
{
typedef typename Cst::size_type size_type;
typedef typename Cst::node_type node_type;
srand(x);
size_type n = cst.csa.size();
// generate nodes
for (size_type i=0; i<times; ++i) {
node_type p = cst.select_leaf(1+ (rand() % n));
nodes.push_back(p);
while (p != cst.root()) {
p = cst.parent(p);
nodes.push_back(p);
}
}
}
void test_cst_1th_child_operation(const Cst& cst, typename Cst::size_type times=1000000, uint64_t x=17)
{
typedef typename Cst::size_type size_type;
typedef typename Cst::node_type node_type;
std::vector<node_type> nodes;
generate_nodes_from_random_leaves(cst, times, nodes, x);
node_type c; // for 1th_child node
size_type cnt=0;
write_R_output("cst","1th_child","begin",nodes.size(),cnt);
for (size_type i=0; i<nodes.size(); ++i) {
c = cst.select_child(nodes[i], 1);
if (c==cst.root())
++cnt;
}
write_R_output("cst","1th_child","end",nodes.size(),cnt);
}
void test_cst_sl_operation(const Cst& cst, typename Cst::size_type times=500, uint64_t x=17)
{
typedef typename Cst::size_type size_type;
typedef typename Cst::node_type node_type;
size_type n = cst.csa.size();
if (times > n)
times = n;
std::vector<node_type> nodes(times);
srand(x);
// take \f$ times \f$ random leaves and calculate each parent
for (size_type i=0; i<times; ++i) {
nodes[i] = cst.parent(cst.select_leaf(rand()%n + 1));
}
size_type cnt=0;
times = 0;
write_R_output("cst","sl","begin",0,cnt);
for (size_type i=0; i<nodes.size(); ++i) {
node_type v = nodes[i];
// std::cout<<"v="<<cst.lb(v)<<" "<<cst.rb(v)<<std::endl;
// size_type d = cst.depth(v);
while (v != cst.root()) { // while v is not the root
++cnt;
v = cst.sl(v); // follow suffix link
// if( cnt < 30 ){
// std::cout<< cnt << " " << cst.lb(v) << " " << cst.rb(v) << " " << cst.depth(v) << std::endl;
// }
// size_type d2 = cst.depth(v);
// if( d != d2+1 ){
// std::cout<<"error at cnt "<<cnt<<" d="<<d<<" d2="<<d2<<std::endl;
// }
// d = d2;
}
}
write_R_output("cst","sl","end",cnt,cnt);
}
void test_cst_lca_operation(const Cst& cst, typename Cst::size_type times=1000000, uint64_t x=17)
{
typedef typename Cst::size_type size_type;
typedef typename Cst::node_type node_type;
// generate \f$2^{19}\f$ random pairs of leafs
size_type n = cst.csa.size();
uint64_t mask = (1<<20)-1;
std::vector<node_type> nodes(1<<20);
srand(x);
for (size_type i=0; i < nodes.size(); ++i) {
nodes[i] = cst.select_leaf(rand()%n + 1);
}
size_type cnt=0;
write_R_output("cst","lca","begin",times,cnt);
for (size_type i=0; i<times; ++i) {
node_type v = cst.lca(nodes[(2*i) & mask], nodes[(2*i+1) & mask]);
if (v == cst.root())
cnt++;
// if(i<30)
// std::cout<<"lca("<<cst.lb(nodes[(2*i)&mask])<<","<<cst.lb(nodes[(2*i+1)&mask])<<")=("<<cst.lb(v)<<","<<cst.rb(v)<<")"<<std::endl;
}
write_R_output("cst","lca","end",times,cnt);
}
