void list_view::set_row_shown(const boost::dynamic_bitset<>& shown) { assert(generator_); assert(shown.size() == get_item_count()); window* window = get_window(); assert(window); const int selected_row = get_selected_row(); bool resize_needed = false; { window::invalidate_layout_blocker invalidate_layout_blocker(*window); for(size_t i = 0; i < shown.size(); ++i) { generator_->set_item_shown(i, shown[i]); } generator_->place(generator_->get_origin(), generator_->calculate_best_size()); // resize_needed = !content_resize_request(); } if(resize_needed) { window->invalidate_layout(); } else { // content_grid_->set_visible_rectangle(content_visible_rectangle()); set_is_dirty(true); } if(selected_row != get_selected_row()) { fire(event::NOTIFY_MODIFIED, *this, nullptr); } }
/****************************************************************************** * Remaps the bonds after some of the particles have been deleted. * Dangling bonds are removed too. ******************************************************************************/ void BondsObject::particlesDeleted(const boost::dynamic_bitset<>& deletedParticlesMask) { // Build map that maps old particle indices to new indices. std::vector<size_t> indexMap(deletedParticlesMask.size()); auto index = indexMap.begin(); size_t oldParticleCount = deletedParticlesMask.size(); size_t newParticleCount = 0; for(size_t i = 0; i < deletedParticlesMask.size(); i++) *index++ = deletedParticlesMask.test(i) ? std::numeric_limits<size_t>::max() : newParticleCount++; auto result = modifiableStorage()->begin(); auto bond = modifiableStorage()->begin(); auto last = modifiableStorage()->end(); for(; bond != last; ++bond) { // Remove invalid bonds. if(bond->index1 >= oldParticleCount || bond->index2 >= oldParticleCount) continue; // Remove dangling bonds whose particles have gone. if(deletedParticlesMask.test(bond->index1) || deletedParticlesMask.test(bond->index2)) continue; // Keep but remap particle indices. result->pbcShift = bond->pbcShift; result->index1 = indexMap[bond->index1]; result->index2 = indexMap[bond->index2]; ++result; } modifiableStorage()->erase(result, last); changed(); }
const bool PartialPage::getBitmap(const unsigned long sequence) const { if (sequence > bitmap.size()) { return false; } return (bitmap[sequence] == 1); }
void multimenu_button::select_options(boost::dynamic_bitset<> states) { assert(states.size() == values_.size()); toggle_states_ = states; update_config_from_toggle_states(); update_label(); }
void DigitalInputWriter::setDigitalInput(const ::boost::dynamic_bitset<>& bitset) { for (::std::size_t i = 0; i < bitset.size(); ++i) { this->setDigitalInput(i, bitset[i]); } }
void bitset_to_vector( binary_truth_table::cube_type& vec, const boost::dynamic_bitset<> number ) { vec.clear(); for ( unsigned i = 0u; i < number.size(); ++i ) { vec.push_back( number.test( i ) ); } }
const bool PartialPage::setBitmap(const unsigned long sequence) { if (sequence > bitmap.size()) { return false; } bitmap[sequence] = 1; return true; }
template<class T> std::vector<T> bitset_to_vector(const boost::dynamic_bitset<>& b) { std::vector<T> v(b.size()); for (size_t i=0; i<v.size(); ++i) { if (b[i]) v[i] = 1; } return v; }
void decrement(boost::dynamic_bitset<> &bitset) { for (unsigned loop = 0; loop < bitset.size(); ++loop) { if ((bitset[loop] ^= 0x1) == 0x0) { break; } } }
void serialize(output_archive& ar, boost::dynamic_bitset<Block, Alloc> const& bs, unsigned) { std::size_t num_bits = bs.size(); std::vector<Block> blocks(bs.num_blocks()); boost::to_block_range(bs, blocks.begin()); ar << num_bits; ar << blocks; }
void listbox::set_row_shown(const boost::dynamic_bitset<>& shown) { assert(generator_); assert(shown.size() == get_item_count()); if(generator_->get_items_shown() == shown) { LOG_GUI_G << LOG_HEADER << " returning early" << std::endl; return; } window* window = get_window(); assert(window); const int selected_row = get_selected_row(); bool resize_needed = false; // Local scope for invalidate_layout_blocker { window::invalidate_layout_blocker invalidate_layout_blocker(*window); for(size_t i = 0; i < shown.size(); ++i) { generator_->set_item_shown(i, shown[i]); } point best_size = generator_->calculate_best_size(); generator_->place(generator_->get_origin(), {std::max(best_size.x, content_visible_area().w), best_size.y}); resize_needed = !content_resize_request(); } if(resize_needed) { window->invalidate_layout(); } else { content_grid_->set_visible_rectangle(content_visible_area()); set_is_dirty(true); } if(selected_row != get_selected_row()) { fire(event::NOTIFY_MODIFIED, *this, nullptr); } }
// // Derive index code from a bitset, that is, return a vector of all indices // that are set in the bitset // std::vector<int> index_code(const boost::dynamic_bitset<>& b) { std::vector<int> v; v.reserve(b.count()); for (int i=0; i<int(b.size()); ++i) { if (b.test(i)) { //if (b[i] == 1) v.push_back(i); } } return v; }
bool executive::ReconvergenceTFGen6::eval_Bra(executive::CTAContext &context, const ir::PTXInstruction &instr, const boost::dynamic_bitset<> & branch, const boost::dynamic_bitset<> & fallthrough) { report("eval_Bra([PC " << context.PC << "])"); // handle nops if (!context.active.count()) { context.PC++; return false; } for (unsigned int id = 0, end = branch.size(); id != end; ++id) { if (branch[id]) { threadPCs[id] = instr.branchTargetInstruction; } } for (unsigned int id = 0, end = fallthrough.size(); id != end; ++id) { if (fallthrough[id]) { ++threadPCs[id]; } } bool divergent = true; if (branch.count() == branch.size()) { context.PC = instr.branchTargetInstruction; divergent = false; } else if (fallthrough.count() == fallthrough.size()) { ++context.PC; divergent = false; } else { context.PC = instr.reconvergeInstruction; } return divergent; }
void removeDeadInstructions(Trace* trace, const boost::dynamic_bitset<>& live) { auto &blocks = trace->getBlocks(); for (auto it = blocks.begin(), end = blocks.end(); it != end;) { auto cur = it; ++it; Block* block = *cur; block->remove_if([&] (const IRInstruction& inst) { assert(inst.getIId() < live.size()); return !live.test(inst.getIId()); }); if (block->empty()) blocks.erase(cur); } }
void tlistbox::set_row_shown(const boost::dynamic_bitset<>& shown) { assert(generator_); assert(shown.size() == get_item_count()); if (generator_->get_items_shown() == shown) { LOG_GUI_G << LOG_HEADER << " returning early" << std::endl; return; } twindow* window = get_window(); assert(window); const int selected_row = get_selected_row(); bool resize_needed; { twindow::tinvalidate_layout_blocker invalidate_layout_blocker(*window); for(size_t i = 0; i < shown.size(); ++i) { generator_->set_item_shown(i, shown[i]); } tpoint best_size = generator_->calculate_best_size(); generator_->place(generator_->get_origin(), { std::max(best_size.x, content_visible_area().w), best_size.y }); resize_needed = !content_resize_request(); } if(resize_needed) { window->invalidate_layout(); } else { content_grid_->set_visible_rectangle(content_visible_area()); set_is_dirty(true); } if(selected_row != get_selected_row() && callback_value_changed_) { callback_value_changed_(*this); } }
void stacked_widget::select_layers(const boost::dynamic_bitset<>& mask) { assert(mask.size() == get_layer_count()); select_layer_impl([&](unsigned int i) { if(mask[i]) { update_selected_layer_index(i); } return mask[i]; }); }
void EditableSceneBody::setLinkVisibilities(const boost::dynamic_bitset<>& visibilities) { int i; const int m = numSceneLinks(); const int n = std::min(m, (int)visibilities.size()); for(i=0; i < n; ++i){ sceneLink(i)->setVisible(visibilities[i]); } while(i < m){ sceneLink(i)->setVisible(false); ++i; } notifyUpdate(impl->modified); }
void randomize(boost::dynamic_bitset<> &bitset) { for (unsigned loop = 0; loop < bitset.size(); ++loop) { double rand_num = (double)rand()/RAND_MAX; if (rand_num < 0.1) { bitset[loop] = true; } else { bitset[loop] = false; } } }
std::string format_binary(const boost::dynamic_bitset<>& b) { std::ostringstream oss; oss.imbue(std::locale::classic()); oss.put('"'); oss << std::hex << std::setw(1); unsigned c = b.size(); unsigned n = (4 - (c % 4)) & 3; oss << n; for (unsigned i = 0; i < c + n;) { unsigned accum = 0; for (int j = 0; j < 4; ++j, ++i) { unsigned bit = i < n ? 0 : b.test(c - i + n - 1) ? 1 : 0; accum |= bit << (3-j); } oss << accum; } oss.put('"'); return oss.str(); }
inline void insert_if_exists(boost::dynamic_bitset<>& cont, const boost::dynamic_bitset<> *other) { if (other && !other->empty()) { cont.resize(std::max(cont.size(), other->size())); cont |= *other; } }
/// \brief Check if the split is informative /// /// \param p The split bool informative(const boost::dynamic_bitset<>& p) { int N = p.size(); int C = p.count(); return (C >= 2) and ((N-C) >= 2); }
Response::Response(bitset<1*BYTE> type, bitset<4*BYTE> ID, boost::dynamic_bitset<> message) :type(type), ID(ID), message(message), datasize(message.size()/8) { CRC = bitset<2*BYTE>(createCRC()); }
/****************************************************************************** * Performs the actual rejection of particles. ******************************************************************************/ size_t SliceModifier::filterParticles(boost::dynamic_bitset<>& mask, TimePoint time, TimeInterval& validityInterval) { // Get the required input properties. ParticlePropertyObject* const posProperty = expectStandardProperty(ParticleProperty::PositionProperty); ParticlePropertyObject* const selProperty = applyToSelection() ? inputStandardProperty(ParticleProperty::SelectionProperty) : nullptr; OVITO_ASSERT(posProperty->size() == mask.size()); OVITO_ASSERT(!selProperty || selProperty->size() == mask.size()); FloatType sliceWidth = 0; if(_widthCtrl) sliceWidth = _widthCtrl->getFloatValue(time, validityInterval); sliceWidth *= 0.5; Plane3 plane = slicingPlane(time, validityInterval); size_t na = 0; boost::dynamic_bitset<>::size_type i = 0; const Point3* p = posProperty->constDataPoint3(); const Point3* p_end = p + posProperty->size(); if(sliceWidth <= 0) { if(selProperty) { const int* s = selProperty->constDataInt(); for(; p != p_end; ++p, ++s, ++i) { if(*s && plane.pointDistance(*p) > 0) { mask.set(i); na++; } else mask.reset(i); } } else { for(; p != p_end; ++p, ++i) { if(plane.pointDistance(*p) > 0) { mask.set(i); na++; } else mask.reset(i); } } } else { bool invert = inverse(); if(selProperty) { const int* s = selProperty->constDataInt(); for(; p != p_end; ++p, ++s, ++i) { if(*s && invert == (plane.classifyPoint(*p, sliceWidth) == 0)) { mask.set(i); na++; } else mask.reset(i); } } else { for(; p != p_end; ++p, ++i) { if(invert == (plane.classifyPoint(*p, sliceWidth) == 0)) { mask.set(i); na++; } else mask.reset(i); } } } return na; }
// finds all possible chiral special cases. // at the moment this is just candidates for ring stereochemistry void findChiralAtomSpecialCases(ROMol &mol, boost::dynamic_bitset<> &possibleSpecialCases) { PRECONDITION(possibleSpecialCases.size() >= mol.getNumAtoms(), "bit vector too small"); possibleSpecialCases.reset(); if (!mol.getRingInfo()->isInitialized()) { VECT_INT_VECT sssrs; MolOps::symmetrizeSSSR(mol, sssrs); } boost::dynamic_bitset<> atomsSeen(mol.getNumAtoms()); boost::dynamic_bitset<> atomsUsed(mol.getNumAtoms()); boost::dynamic_bitset<> bondsSeen(mol.getNumBonds()); for (ROMol::AtomIterator ait = mol.beginAtoms(); ait != mol.endAtoms(); ++ait) { const Atom *atom = *ait; if (atomsSeen[atom->getIdx()]) continue; if (atom->getChiralTag() == Atom::CHI_UNSPECIFIED || atom->hasProp(common_properties::_CIPCode) || !mol.getRingInfo()->numAtomRings(atom->getIdx()) || !atomIsCandidateForRingStereochem(mol, atom)) { continue; } // do a BFS from this ring atom along ring bonds and find other // stereochemistry candidates. std::list<const Atom *> nextAtoms; // start with finding viable neighbors ROMol::OEDGE_ITER beg, end; boost::tie(beg, end) = mol.getAtomBonds(atom); while (beg != end) { unsigned int bidx = mol[*beg]->getIdx(); if (!bondsSeen[bidx]) { bondsSeen.set(bidx); if (mol.getRingInfo()->numBondRings(bidx)) { const Atom *oatom = mol[*beg]->getOtherAtom(atom); if (!atomsSeen[oatom->getIdx()]) { nextAtoms.push_back(oatom); atomsUsed.set(oatom->getIdx()); } } } ++beg; } INT_VECT ringStereoAtoms(0); if (!nextAtoms.empty()) { atom->getPropIfPresent(common_properties::_ringStereoAtoms, ringStereoAtoms); } while (!nextAtoms.empty()) { const Atom *ratom = nextAtoms.front(); nextAtoms.pop_front(); atomsSeen.set(ratom->getIdx()); if (ratom->getChiralTag() != Atom::CHI_UNSPECIFIED && !ratom->hasProp(common_properties::_CIPCode) && atomIsCandidateForRingStereochem(mol, ratom)) { int same = (ratom->getChiralTag() == atom->getChiralTag()) ? 1 : -1; ringStereoAtoms.push_back(same * (ratom->getIdx() + 1)); INT_VECT oringatoms(0); ratom->getPropIfPresent(common_properties::_ringStereoAtoms, oringatoms); oringatoms.push_back(same * (atom->getIdx() + 1)); ratom->setProp(common_properties::_ringStereoAtoms, oringatoms, true); possibleSpecialCases.set(ratom->getIdx()); possibleSpecialCases.set(atom->getIdx()); } // now push this atom's neighbors boost::tie(beg, end) = mol.getAtomBonds(ratom); while (beg != end) { unsigned int bidx = mol[*beg]->getIdx(); if (!bondsSeen[bidx]) { bondsSeen.set(bidx); if (mol.getRingInfo()->numBondRings(bidx)) { const Atom *oatom = mol[*beg]->getOtherAtom(ratom); if (!atomsSeen[oatom->getIdx()] && !atomsUsed[oatom->getIdx()]) { nextAtoms.push_back(oatom); atomsUsed.set(oatom->getIdx()); } } } ++beg; } } // end of BFS if (ringStereoAtoms.size() != 0) { atom->setProp(common_properties::_ringStereoAtoms, ringStereoAtoms, true); // because we're only going to hit each ring atom once, the first atom we // encounter in a ring is going to end up with all the other atoms set as // stereoAtoms, but each of them will only have the first atom present. We // need to fix that. because the traverse from the first atom only // followed ring bonds, these things are all by definition in one ring // system. (Q: is this true if there's a spiro center in there?) INT_VECT same(mol.getNumAtoms(), 0); BOOST_FOREACH (int ringAtomEntry, ringStereoAtoms) { int ringAtomIdx = ringAtomEntry < 0 ? -ringAtomEntry - 1 : ringAtomEntry - 1; same[ringAtomIdx] = ringAtomEntry; } for (INT_VECT_CI rae = ringStereoAtoms.begin(); rae != ringStereoAtoms.end(); ++rae) { int ringAtomEntry = *rae; int ringAtomIdx = ringAtomEntry < 0 ? -ringAtomEntry - 1 : ringAtomEntry - 1; INT_VECT lringatoms(0); mol.getAtomWithIdx(ringAtomIdx) ->getPropIfPresent(common_properties::_ringStereoAtoms, lringatoms); CHECK_INVARIANT(lringatoms.size() > 0, "no other ring atoms found."); for (INT_VECT_CI orae = rae + 1; orae != ringStereoAtoms.end(); ++orae) { int oringAtomEntry = *orae; int oringAtomIdx = oringAtomEntry < 0 ? -oringAtomEntry - 1 : oringAtomEntry - 1; int theseDifferent = (ringAtomEntry < 0) ^ (oringAtomEntry < 0); lringatoms.push_back(theseDifferent ? -(oringAtomIdx + 1) : (oringAtomIdx + 1)); INT_VECT olringatoms(0); mol.getAtomWithIdx(oringAtomIdx) ->getPropIfPresent(common_properties::_ringStereoAtoms, olringatoms); CHECK_INVARIANT(olringatoms.size() > 0, "no other ring atoms found."); olringatoms.push_back(theseDifferent ? -(ringAtomIdx + 1) : (ringAtomIdx + 1)); mol.getAtomWithIdx(oringAtomIdx) ->setProp(common_properties::_ringStereoAtoms, olringatoms); } mol.getAtomWithIdx(ringAtomIdx) ->setProp(common_properties::_ringStereoAtoms, lringatoms); } } else {