int main(const int argc, const char** argv) {
BitSet<24, char> bitset;
bitset.set(14);
std::cout << bitset.get(14) << "\n";
bitset.debug_print();
const size_t test_indices[] = {
26, 155, 95, 9, 3, 183, 154, 130, 102, 103, 105, 19,
161, 190, 61, 162, 183, 11, 3, 88, 18, 155, 169, 73,
59, 58, 0, 105, 191, 140, 191, 91, 3, 4, 139, 176, 176,
180, 168, 16, 143, 96, 77, 38, 178, 189, 118, 109, 138,
69, 110, 102, 66, 85, 32, 190, 76, 66, 86, 40, 35, 104,
101, 89, 124, 27, 125, 46, 134, 96, 93, 161, 178, 83, 114,
128, 8, 55, 108, 167, 11, 184, 74, 164, 169, 101, 140, 31,
120, 167, 190, 85, 158, 118, 19, 63, 175, 155, 80, 58
};
for (const auto& test_idx: test_indices) {
bitset.set(test_idx);
bool ans = bitset.get(test_idx);
if (!ans) {
throw std::runtime_error("Failed test");
}
}
bitset.debug_print();
}
BitSet ATNConfigSet::getAlts() {
BitSet alts;
for (ATNConfig config : configs) {
alts.set(config.alt);
}
return alts;
}
void PVCopy::initCopy(
PVStructure ©PVStructure, BitSet &bitSet, bool lockRecord)
{
bitSet.clear();
bitSet.set(0);
updateCopyFromBitSet(copyPVStructure,bitSet,lockRecord);
}
BitSet* ChainedFilter::bits( IndexReader* reader, int logic )
{
BitSet* bts = NULL;
Filter** filter = filters;
// see discussion at top of file
if( *filter ) {
BitSet* tmp = (*filter)->bits( reader );
if ( (*filter)->shouldDeleteBitSet(tmp) ) //if we are supposed to delete this BitSet, then
bts = tmp; //we can safely call it our own
else if ( tmp == NULL ){
int32_t len = reader->maxDoc();
bts = _CLNEW BitSet( len ); //bitset returned null, which means match _all_
for (int32_t i=0;i<len;i++ )
bts->set(i);
}else{
bts = tmp->clone(); //else it is probably cached, so we need to copy it before using it.
}
filter++;
}
else
bts = _CLNEW BitSet( reader->maxDoc() );
while( *filter ) {
doChain( bts, reader, logic, *filter );
filter++;
}
return bts;
}
void BitVector<dim>::unslice(BitSet<dim> t,size_t new_size)
{
BitSet<dim> result;
for (typename BitSet<dim>::iterator it=t.begin(); it();
d_data>>=1,++it)
result.set(*it,d_data[0]);
d_data=result;
d_size=new_size;
}
NFAFrag NFA::cloneFrag(const NFAFrag& frag)
{
list<NFAState*> workList;
BitSet visited;
workList.push_back(frag.start);
visited.set(frag.start->stateId);
map<NFAState*,NFAState*> old2new;
typedef map<NFAState*,NFAState*>::iterator Old2NewIter;
while(!workList.empty())
{
NFAState* cur_state=workList.front();workList.pop_front();
for(map<int,NFAState*>::iterator it=cur_state->cedges.begin();it!=cur_state->cedges.end();++it)
{
NFAState* nextstate=0;
Old2NewIter findit;
if((findit=old2new.find(it->second))==old2new.end())
{
old2new[it->second]=nextstate=newState();
}
else
nextstate=findit->second;
cur_state->cedges[it->first]=nextstate;
if(!visited[nextstate->stateId])
workList.push_back(nextstate);
}
for(NFAStateArrIter it=cur_state->eedges.begin();it!=cur_state->eedges.end();++it)
{
NFAState* nextstate=0;
Old2NewIter findit;
if((findit=old2new.find(*it))==old2new.end())
{
old2new[*it]=nextstate=newState();
}
else
nextstate=findit->second;
patch(cur_state,nextstate);
if(!visited[nextstate->stateId])
workList.push_back(nextstate);
}
}
NFAFrag ret(old2new[frag.start],old2new[frag.out]);
return ret;
}
// only set epsilon bits
void quickEclosure(NFAState* start,DFAState* res,BitSet& visited)
{
if(visited[start->stateId]) return;
visited.set(start->stateId);
res->nfaBits.or(start->eBits);
for(NFAStateArrIter it=start->eedges.begin();it!=start->eedges.end();++it)
{
quickEclosure(*it,res,visited);
}
}
Seq<T> *newnode(T item) {
members.set(item->id);
Seq<T>* n = free;
if (n) {
free = n->tail;
n->head = item;
} else {
n = new (alloc) Seq<T> (item);
}
return n;
}
int main()
{
BitSet<8> a;
a.set(0);
a.set(1);
a.set(2);
BitSet<8> b;
b.set(3);
cout << a.intersects(b) << endl;
b.set(1);
cout << a.intersects(b) << endl;
a.set(451);
cout << a.size() << endl;
return 0;
}
void SCCP::analyzeBlock(BlockStartInstr* block) {
// mark each instruction in the block.
for (InstrRange i(block); !i.empty(); i.popFront())
mark.set(i.front()->id);
// evaluate each instruction and queue all reachable users.
for (InstrRange i(block); !i.empty(); i.popFront()) {
Instr* instr = i.front();
eval_counts[instr->id]++;
analyzer.computeTypes(instr);
addInstrUsers(instr);
}
analyzeBranch(ir->blockEnd(block));
}
/**
* Move the bits set in acc to the places specified by mapping.
*/
void move_acceptance_bits(BitSet& acc,
std::vector<unsigned int> mapping) {
int i=acc.nextSetBit(0);
while (i!=-1) {
unsigned int j=mapping[i];
// :: j is always <= i
if (j>(unsigned int)i) {
THROW_EXCEPTION(Exception, "Wrong mapping in move_acceptance_bits");
}
if (((unsigned int)i) == j) {
// do nothing
} else {
// move bit from i->j
acc.set(j);
acc.clear(i);
}
i=acc.nextSetBit(i+1);
}
}
static void exampleDouble(PvaClientPtr const &pvaClient)
{
testDiag("== exampleDouble ==");
PvaClientChannelPtr pvaChannel;
try {
pvaChannel = pvaClient->createChannel("PVRdouble");
pvaChannel->connect(2.0);
testDiag("channel connected");
} catch (std::runtime_error e) {
testAbort("channel connection exception '%s'", e.what());
}
PvaClientPutPtr put;
PvaClientPutDataPtr putData;
try {
put = pvaChannel->createPut();
putData = put->getData();
testDiag("put connected");
if (!putData)
testAbort("NULL data pointer from putGet");
} catch (std::runtime_error e) {
testAbort("put connection exception '%s'", e.what());
}
PvaClientGetPtr get;
PvaClientGetDataPtr getData;
try {
get = pvaChannel->createGet();
getData = get->getData();
testDiag("get connected");
if (!getData)
testAbort("NULL data pointer from putGet");
} catch (std::runtime_error e) {
testAbort("get connection exception '%s'", e.what());
}
PvaClientMonitorRequesterPtr requester(new MyMonitor());
PvaClientMonitorPtr monitor;
expected.set(0); // structure definition
try {
monitor = pvaChannel->monitor(requester);
testDiag("monitor connected");
} catch (std::runtime_error e) {
testAbort("monitor connection exception '%s'", e.what());
}
epicsThreadSleep(0.1); // Allow connection monitor event to fire
expected.clear(); // FIXME: Magic numbers here...
expected.set(1); // value
expected.set(6); // timestamp
try {
for (int i=0; i<5; ++i) {
testDiag("= put %d =", i);
double out = i;
putData->putDouble(out);
put->put();
get->get();
double in = getData->getDouble();
testOk(in == out, "get value matches put");
}
PvaClientProcessPtr process = pvaChannel->createProcess();
process->connect();
testDiag("= process =");
expected.clear(1); // no value change
process->process();
} catch (std::runtime_error e) {
testAbort("exception '%s'", e.what());
}
}
VectorIterator<Entity*, EntityControllerFilter> EntityList::filterByControllers(vector<size_t> controllerIds)
{
BitSet bitset;
for(unsigned int i{0}; i < controllerIds.size(); ++i) bitset.set(i, controllerIds[i]);
return filter( EntityControllerFilter(bitset) );
}
static void testSerialize()
{
testDiag("testSerialization");
#define TOFRO(BB, BES, LES) do{tofrostring(BB, BES, NELEMENTS(LES)-1, EPICS_ENDIAN_BIG); \
tofrostring(BB, LES, NELEMENTS(LES)-1, EPICS_ENDIAN_LITTLE);}while(0)
{
BitSet dut;
TOFRO(dut, "\x00",
"\x00"); // zero size
}
{
BitSet dut;
dut.set(0);
TOFRO(dut, "\x01\x01",
"\x01\x01");
}
{
BitSet dut;
dut.set(1);
TOFRO(dut, "\x01\x02",
"\x01\x02");
}
{
BitSet dut;
dut.set(8);
TOFRO(dut, "\x02\x00\x01",
"\x02\x00\x01"); // high 64-bit word always LSB
}
{
BitSet dut;
dut.set(55);
dut.set(1);
TOFRO(dut, "\x07\x02\x00\x00\x00\x00\x00\x80",
"\x07\x02\x00\x00\x00\x00\x00\x80");
}
{
BitSet dut;
dut.set(63);
dut.set(1);
TOFRO(dut, "\x08\x80\x00\x00\x00\x00\x00\x00\x02",
"\x08\x02\x00\x00\x00\x00\x00\x00\x80");
}
{
BitSet dut;
dut.set(64);
dut.set(63);
dut.set(8);
dut.set(1);
TOFRO(dut, "\x09\x80\x00\x00\x00\x00\x00\x01\x02\x01",
"\x09\x02\x01\x00\x00\x00\x00\x00\x80\x01");
}
{
BitSet dut;
dut.set(126);
dut.set(64);
dut.set(63);
dut.set(1);
TOFRO(dut, "\x10\x80\x00\x00\x00\x00\x00\x00\x02\x40\x00\x00\x00\x00\x00\x00\x01",
"\x10\x02\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x40");
}
#undef TOFRO
}
