Partition::Partition(const vector<string>& n,const dynamic_bitset<>& g,const dynamic_bitset<>& mask) :names(n),group1((~ g) & mask),group2(g & mask) { assert(n.size() == g.size()); assert(g.size() == mask.size()); assert(not group1.intersects(group2)); }
uint32_t cFixedAlloc::findFirstOf(bool check, dynamic_bitset<>& bit) { for ( int i = 0; i < bit.size(); ++i ) { if ( bit[i] == check ) return i; } return bit.size() + 1; }
/// Check that any two present nodes are connected by a path of present nodes bool all_characters_connected(const Tree& T,dynamic_bitset<> present,const vector<int>& _ignore) { assert(present.size() == T.n_nodes()); //--------- set the ignored nodes to 'not present' -----------// dynamic_bitset<> ignore(present.size()); for(int i=0;i<_ignore.size();i++) { int n = _ignore[i]; present[n] = false; ignore[n] = true; } //---------- for each internal node... -------------// for(int n1=T.n_leaves(); n1<T.n_nodes(); n1++) { if (present[n1] or ignore[n1]) continue; //------- if it is '-' and not ignored ... -------// vector<const_nodeview> neighbors; append(T[n1].neighbors(),neighbors); assert(neighbors.size() == 3); //---- check the three attatched subtrees ... ----// int total=0; for(int i=0;i<neighbors.size();i++) { dynamic_bitset<> group = T.partition(n1,neighbors[i]); if (present.intersects(group)) total++; } //----- nodes should be present in only one. -----// if (total > 1) return false; } return true; }
typename allocator<T>::size_type allocator<T>::find_free_memory(const dynamic_bitset & memfree, dynamic_bitset & mask) { /* search mask in memfree */ const size_type needed_mem_size = mask.count(); if (memfree.count() < needed_mem_size) { # if DEBUG_SMA_TRACE_FIND_FREE_MEM std::cout << "not enough free memory found" << std::endl; # endif return memfree.size(); } assert(needed_mem_size <= memfree.size()); const size_type asize = memfree.size() - needed_mem_size; size_type pos = 0; while (pos <= asize) { # if DEBUG_SMA_TRACE_FIND_FREE_MEM std::cout << "pos: " << pos << "/" << asize << std::endl; std::cout << "mask: " << mask << std::endl; std::cout << "memfree: " << memfree << std::endl; # endif /* check if enough memory is free in interval [pos, pos+needed_mem_size) */ if ((memfree & mask) == mask) { /* free memory found */ # if DEBUG_SMA_TRACE_FIND_FREE_MEM std::cout << "free memory found at pos=" << pos << std::endl; # endif return pos; } else { /* increment pos for next iteration */ # if DEBUG_SMA_TRACE_FIND_FREE_MEM std::cout << "memfree: " << memfree << " " << memfree << std::endl; std::cout << "inc mask: " << mask << " -> "; # endif const size_type oldpos = pos; pos = memfree.find_next(oldpos); assert(pos >= oldpos); mask <<= pos - oldpos; # if DEBUG_SMA_TRACE_FIND_FREE_MEM std::cout << mask << std::endl; std::cout << "pos: " << oldpos << " -> " << pos << std::endl; # endif assert(mask.count() == needed_mem_size); } } /* no free memory found */ # if DEBUG_SMA_TRACE_FIND_FREE_MEM std::cout << "not enough free memory found" << std::endl; # endif return memfree.size(); }
typename allocator<T>::dynamic_bitset allocator<T>::free_memory(const dynamic_bitset & memfree, dynamic_bitset && mask) { assert(memfree.size() == mask.size()); assert(memfree.count() + mask.count() <= memfree.size()); auto res = memfree | mask; # if DEBUG_SMA_TRACE_BITSET std::cout << "a=memfree: " << memfree << std::endl; std::cout << "b= mask: " << mask << std::endl; std::cout << "r= a | b: " << res << std::endl; # endif assert(memfree.count() + mask.count() == res.count()); return res; }
bool compare_complete_partitions::operator()(const dynamic_bitset<>& p1, const dynamic_bitset<>& p2) const { assert(p1.size() == p2.size()); for(int i=0;i<p1.size();i++) { if (p2[i] and not p1[i]) return true; if (p1[i] and not p2[i]) return false; } return false; }
static bool can_die_early(const NGHolder &g, const vector<StateInfo> &info, const dynamic_bitset<> &s, map<dynamic_bitset<>, u32> &visited, u32 age_limit) { if (contains(visited, s) && visited[s] >= age_limit) { /* we have already (or are in the process) of visiting here with a * looser limit. */ return false; } visited[s] = age_limit; if (s.none()) { DEBUG_PRINTF("dead\n"); return true; } if (age_limit == 0) { return false; } dynamic_bitset<> all_succ(s.size()); step(g, info, s, &all_succ); all_succ.reset(NODE_START_DOTSTAR); for (u32 i = 0; i < N_CHARS; i++) { dynamic_bitset<> next = all_succ; filter_by_reach(info, &next, CharReach(i)); if (can_die_early(g, info, next, visited, age_limit - 1)) { return true; } } return false; }
void connect_all_characters(const Tree& T,dynamic_bitset<>& present) { assert(present.size() == T.n_nodes()); //---------- for each internal node... -------------// for(int n1=T.n_leaves(); n1<T.n_nodes(); n1++) { if (present[n1]) continue; //------- if it is '-' and not ignored ... -------// vector<const_nodeview> neighbors; append(T[n1].neighbors(),neighbors); assert(neighbors.size() == 3); //---- check the three attatched subtrees ... ----// int total=0; for(int i=0;i<neighbors.size();i++) { dynamic_bitset<> group = T.partition(n1,neighbors[i]); if (present.intersects(group)) total++; } if (total > 1) present[n1] = true; } assert(all_characters_connected(T,present,vector<int>())); }
bool A_constant(alignment A1, alignment A2, const dynamic_bitset<>& ignore) { assert(A1.n_sequences() == A2.n_sequences()); // equality holds if we have internal node sequences -- otherwise ignore is larger assert(A1.n_sequences() <= ignore.size()); // convert to feature-number notation ublas::matrix<int> M1 = M(A1); ublas::matrix<int> M2 = M(A2); // lookup and cache the column each feature is in vector< vector< int> > column_indices = column_lookup(A2); //----- Check that the sequence lengths match ------// for(int i=0;i<M1.size2();i++) { if (ignore[i]) continue; if (A1.seqlength(i) != A2.seqlength(i)) return false; } //----- Check that each homology in A1 is in A2 -----// for(int column=0; column<A1.length(); column++) for(int s1=0; s1 < A1.n_sequences(); s1++) { if (ignore[s1]) continue; for(int s2=s1+1; s2 < A1.n_sequences(); s2++) { if (ignore[s2]) continue; if (not A_match(M1,column,s1,s2,M2,column_indices)) return false; } } return true; }
vector<int> diffset_for_single_item(dynamic_bitset<> tids) { vector<int> diffset; dynamic_bitset<>::size_type size = tids.size(); for (dynamic_bitset<>::size_type i = 0; i < size; ++i) if ( ! tids.test(i)) diffset.push_back(i); return diffset; }
Partition::Partition(const Partition& p,const dynamic_bitset<>& mask) :names(p.names), group1(p.group1 & mask), group2(p.group2 & mask) { assert(mask.size() == p.group1.size()); assert(not group1.intersects(group2)); }
void StreamGenerator::setBitstreamBits(dynamic_bitset<>& bitStream, int num, size_t bitsetIndex, size_t numIndex) { unsigned int size = sizeof (unsigned int)*8; if (numIndex < size) { if (bitsetIndex < bitStream.size()) { bitStream[bitsetIndex] = (num >> numIndex) & 0x1; setBitstreamBits(bitStream, num, bitsetIndex + 1, numIndex + 1); } }
int Tree::induce_partition(const dynamic_bitset<>& partition) { assert(partition.size() == n_leaves()); prepare_partitions(); dynamic_bitset<> partition1(n_nodes()); dynamic_bitset<> partition2(n_nodes()); // copy bits from smaller bitset on leaves to larger bitset on all nodes for(int i=0;i<partition.size();i++) { if (partition[i]) partition1.flip(i); else partition2.flip(i); } for(int i=n_leaves();i<n_nodes();i++) { vector<BranchNode*> group1; vector<BranchNode*> group2; // divide the branches out into two groups BranchNode * BN = nodes_[i]; do { if (not partition1.intersects(cached_partitions[BN->branch])) group2.push_back(BN); else if (not partition2.intersects(cached_partitions[BN->branch])) group1.push_back(BN); else { group1.clear(); group2.clear(); break; } BN = BN->next; } while (BN != nodes_[i]); // this node can't separate the groups if (not group1.size() and not group2.size()) continue; BranchNode* bn = NULL; // groups are already split! if (group1.size() == 1) bn = group1[0]; // groups are already split! else if (group2.size() == 1) bn = group2[0]; // split the node and note the name of the newly added branch else { bn = split_node(group1,group2); reanalyze(nodes_[0]); } if (not bn) return -1; else return std::min(bn->branch,bn->out->branch); } throw myexception()<<"induce_partition: partition conflicts with tree!"; }
Partition::Partition(const dynamic_bitset<>& g,const dynamic_bitset<>& mask) :group1((~g) & mask),group2(g & mask) { assert(g.size() == mask.size()); assert(not group1.intersects(group2)); }
Partition::Partition(const vector<string>& n,const dynamic_bitset<>& g) :names(n),group1(g),group2(~g) { assert(n.size() == g.size()); assert(not group1.intersects(group2)); }