void
Ticket_ATTLC::Validate(Bits& b)
{
unsigned int count = 0;
while (b[count])
count++;
while (count >= b.size())
b.size(b.size() + bits_increment);
num = count;
b.set(num);
}
void EagerBitblaster::makeVariable(TNode var, Bits& bits) {
Assert(bits.size() == 0);
for (unsigned i = 0; i < utils::getSize(var); ++i) {
bits.push_back(utils::mkBitOf(var, i));
}
d_variables.insert(var);
}
void
print_bitset(Bits b, size_t size = 0)
{
if (size == 0)
size = b.size();
for (size_t pos = b.find_first(); pos < size && pos != string::npos; pos = b.find_next(pos))
{
std::cout << pos << ", ";
}
std::cout << std::endl;
}
/**
* Returns the value a is currently assigned to in the SAT solver
* or null if the value is completely unassigned.
*
* @param a
* @param fullModel whether to create a "full model," i.e., add
* constants to equivalence classes that don't already have them
*
* @return
*/
Node TLazyBitblaster::getVarValue(TNode a, bool fullModel) {
if (!hasBBTerm(a)) {
Assert(isSharedTerm(a));
return Node();
}
Bits bits;
getBBTerm(a, bits);
Integer value(0);
for (int i = bits.size() -1; i >= 0; --i) {
prop::SatValue bit_value;
if (d_cnfStream->hasLiteral(bits[i])) {
prop::SatLiteral bit = d_cnfStream->getLiteral(bits[i]);
bit_value = d_satSolver->value(bit);
Assert (bit_value != prop::SAT_VALUE_UNKNOWN);
} else {
// the bit is unconstrainted so we can give it an arbitrary value
bit_value = prop::SAT_VALUE_FALSE;
}
Integer bit_int = bit_value == prop::SAT_VALUE_TRUE ? Integer(1) : Integer(0);
value = value * 2 + bit_int;
}
return utils::mkConst(BitVector(bits.size(), value));
}
void __hashbits(hash_t *hash, void *data, uint32_t size) {
// compute hash of data.
Bits bits(size * 8);
ByteArrayToBits(data, size, bits);
Bits hashBits = _hasher->hash(bits);
for (uint32_t i = 0; i < hashBits.size() / 8; i++) {
uint8_t* chunk = &(((uint8_t*)hash)[i]);
*chunk = 0;
for (uint32_t j = 0; j < 8; j++) {
*chunk |= (hashBits[DB_HASH_NUM_BITS - (i * 8 + j) - 1] << j);
}
}
}
void EagerBitblaster::bbTerm(TNode node, Bits& bits) {
if (hasBBTerm(node)) {
getBBTerm(node, bits);
return;
}
d_bv->spendResource(options::bitblastStep());
Debug("bitvector-bitblast") << "Bitblasting node " << node <<"\n";
d_termBBStrategies[node.getKind()] (node, bits, this);
Assert (bits.size() == utils::getSize(node));
storeBBTerm(node, bits);
}
/**
* Returns the value a is currently assigned to in the SAT solver
* or null if the value is completely unassigned.
*
* @param a
* @param fullModel whether to create a "full model," i.e., add
* constants to equivalence classes that don't already have them
*
* @return
*/
Node EagerBitblaster::getModelFromSatSolver(TNode a, bool fullModel) {
if (!hasBBTerm(a)) {
return fullModel? utils::mkConst(utils::getSize(a), 0u) : Node();
}
Bits bits;
getBBTerm(a, bits);
Integer value(0);
for (int i = bits.size() -1; i >= 0; --i) {
prop::SatValue bit_value;
if (d_cnfStream->hasLiteral(bits[i])) {
prop::SatLiteral bit = d_cnfStream->getLiteral(bits[i]);
bit_value = d_satSolver->value(bit);
Assert (bit_value != prop::SAT_VALUE_UNKNOWN);
} else {
if (!fullModel) return Node();
// unconstrained bits default to false
bit_value = prop::SAT_VALUE_FALSE;
}
Integer bit_int = bit_value == prop::SAT_VALUE_TRUE ? Integer(1) : Integer(0);
value = value * 2 + bit_int;
}
return utils::mkConst(BitVector(bits.size(), value));
}
void TLazyBitblaster::bbTerm(TNode node, Bits& bits) {
if (hasBBTerm(node)) {
getBBTerm(node, bits);
return;
}
Debug("bitvector-bitblast") << "Bitblasting node " << node <<"\n";
++d_statistics.d_numTerms;
d_termBBStrategies[node.getKind()] (node, bits,this);
Assert (bits.size() == utils::getSize(node));
storeBBTerm(node, bits);
}
bool TLazyBitblaster::hasValue(TNode a) {
Assert (hasBBTerm(a));
Bits bits;
getBBTerm(a, bits);
for (int i = bits.size() -1; i >= 0; --i) {
prop::SatValue bit_value;
if (d_cnfStream->hasLiteral(bits[i])) {
prop::SatLiteral bit = d_cnfStream->getLiteral(bits[i]);
bit_value = d_satSolver->value(bit);
if (bit_value == prop::SAT_VALUE_UNKNOWN)
return false;
} else {
return false;
}
}
return true;
}
Signal
BluetoothTransmitter::modulate(const Bits& input, double df) {
Signal modOut(Ns * input.size());
int offset = 0;
double phase=getPhase();
for (int i=0; i<input.size(); ++i) {
for(int j=0; j<Ns; ++j) {
double tt=twopi*df*(j+Ns*i)/((double)Ns);
if (tt>twopi) { tt=fmod(tt,twopi); }
double state = qsign(input[i])*s_qcoef[j] +
qsign(m_prev)*s_qcoef[j+Ns] + phase;
modOut[offset+j] = exp(Sample(0.0,twopi* (m_hf * state)+tt));
} // end j
// Update phase and previous bit value
phase += (m_prev ? -0.5 : 0.5);
m_prev = input[i];
offset += Ns;
} // end i
setPhase(phase);
return modOut;
}