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 {
