/// Cross-off the next multiple of each sieving prime within the
/// current bucket. This is an implementation of the segmented sieve
/// of Eratosthenes with wheel factorization optimized for big sieving
/// primes that have very few multiples per segment. This algorithm
/// uses a modulo 210 wheel that skips multiples of 2, 3, 5 and 7.
///
void EratBig::crossOff(byte_t* sieve, SievingPrime* sPrime, SievingPrime* sEnd)
{
Bucket** lists = &lists_[0];
uint_t moduloSieveSize = moduloSieveSize_;
uint_t log2SieveSize = log2SieveSize_;
// 2 sieving primes are processed per loop iteration
// to increase instruction level parallelism
for (; sPrime + 2 <= sEnd; sPrime += 2)
{
uint_t multipleIndex0 = sPrime[0].getMultipleIndex();
uint_t wheelIndex0 = sPrime[0].getWheelIndex();
uint_t sievingPrime0 = sPrime[0].getSievingPrime();
uint_t multipleIndex1 = sPrime[1].getMultipleIndex();
uint_t wheelIndex1 = sPrime[1].getWheelIndex();
uint_t sievingPrime1 = sPrime[1].getSievingPrime();
// cross-off the current multiple (unset bit)
// and calculate the next multiple
unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0);
unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1);
uint_t segment0 = multipleIndex0 >> log2SieveSize;
uint_t segment1 = multipleIndex1 >> log2SieveSize;
multipleIndex0 &= moduloSieveSize;
multipleIndex1 &= moduloSieveSize;
// move the 2 sieving primes to the list related
// to their next multiple
if (!lists[segment0]->store(sievingPrime0, multipleIndex0, wheelIndex0))
pushBucket(segment0);
if (!lists[segment1]->store(sievingPrime1, multipleIndex1, wheelIndex1))
pushBucket(segment1);
}
if (sPrime != sEnd)
{
uint_t multipleIndex = sPrime->getMultipleIndex();
uint_t wheelIndex = sPrime->getWheelIndex();
uint_t sievingPrime = sPrime->getSievingPrime();
unsetBit(sieve, sievingPrime, &multipleIndex, &wheelIndex);
uint_t segment = multipleIndex >> log2SieveSize;
multipleIndex &= moduloSieveSize;
if (!lists[segment]->store(sievingPrime, multipleIndex, wheelIndex))
pushBucket(segment);
}
void MSEntryFieldCombo::comboButtonLabel(const MSString& label_)
{
_buttonLabel = label_;
if(_buttonLabel == "") unsetBit(TextButton);
else setBit(TextButton);
placement();
}
void setDblTime(uint8_t state){
if (state == OFF){
setAsInput(DBLTIME);
} else {
setAsOutput(DBLTIME);
unsetBit(PORTB, DBLTIME);
}
}
/// Cross-off the multiples of the sieving primes within the current
/// bucket. This is an implementation of the segmented sieve of
/// Eratosthenes with wheel factorization optimized for medium sieving
/// primes that have a few multiples per segment. This algorithm uses
/// a modulo 210 wheel that skips multiples of 2, 3, 5 and 7.
///
void EratMedium::crossOff(byte_t* sieve, uint_t sieveSize, Bucket& bucket)
{
SievingPrime* sPrime = bucket.begin();
SievingPrime* sEnd = bucket.end();
// process 3 sieving primes per loop iteration to
// increase instruction level parallelism
for (; sPrime + 3 <= sEnd; sPrime += 3)
{
uint_t multipleIndex0 = sPrime[0].getMultipleIndex();
uint_t wheelIndex0 = sPrime[0].getWheelIndex();
uint_t sievingPrime0 = sPrime[0].getSievingPrime();
uint_t multipleIndex1 = sPrime[1].getMultipleIndex();
uint_t wheelIndex1 = sPrime[1].getWheelIndex();
uint_t sievingPrime1 = sPrime[1].getSievingPrime();
uint_t multipleIndex2 = sPrime[2].getMultipleIndex();
uint_t wheelIndex2 = sPrime[2].getWheelIndex();
uint_t sievingPrime2 = sPrime[2].getSievingPrime();
// cross-off the multiples (unset bits) of sievingPrime
// @see unsetBit() in WheelFactorization.hpp
while (multipleIndex0 < sieveSize)
{
unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0);
if (multipleIndex1 >= sieveSize) break;
unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1);
if (multipleIndex2 >= sieveSize) break;
unsetBit(sieve, sievingPrime2, &multipleIndex2, &wheelIndex2);
}
while (multipleIndex0 < sieveSize) unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0);
while (multipleIndex1 < sieveSize) unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1);
while (multipleIndex2 < sieveSize) unsetBit(sieve, sievingPrime2, &multipleIndex2, &wheelIndex2);
multipleIndex0 -= sieveSize;
multipleIndex1 -= sieveSize;
multipleIndex2 -= sieveSize;
sPrime[0].set(multipleIndex0, wheelIndex0);
sPrime[1].set(multipleIndex1, wheelIndex1);
sPrime[2].set(multipleIndex2, wheelIndex2);
}
// process remaining sieving primes
for (; sPrime != sEnd; sPrime++)
{
uint_t multipleIndex = sPrime->getMultipleIndex();
uint_t wheelIndex = sPrime->getWheelIndex();
uint_t sievingPrime = sPrime->getSievingPrime();
while (multipleIndex < sieveSize)
unsetBit(sieve, sievingPrime, &multipleIndex, &wheelIndex);
multipleIndex -= sieveSize;
sPrime->set(multipleIndex, wheelIndex);
}
}
void setTempoScale(uint8_t state){
switch (state) {
case D1_1: default:
setAsOutput(TEMPOSCALE);
setBit(PORTB, TEMPOSCALE);
break;
case D1_2:
setAsOutput(TEMPOSCALE);
unsetBit(PORTB, TEMPOSCALE);
break;
case D3_4:
setAsInput(TEMPOSCALE);
break;
}
}
void MSEntryFieldCombo::buttonState(ButtonFlag button_, MSBoolean flag_)
{
if(button_ == TextButton) return; // use comboButtonLabel instead
if(bitState(button_) != flag_)
{
if(flag_ == MSTrue) setBit(button_);
else unsetBit(button_);
switch(button_)
{
case UpDownArrows:
if(_upArrow == 0) _upArrow=new MSArrow(this,MSArrow::Up);
if(_downArrow == 0) _downArrow=new MSArrow(this,MSArrow::Down);
break;
case ComboButton:
if (_comboArrow == 0) _comboArrow = new MSArrow(this, MSArrow::Down);
default:
break;
}
}
placement();
}
bool Bitmap::unsetBit(size_t bit_number)
{
assert(bit_number < size_);
return unsetBit(bitmap_, num_bits_set_, bit_number);
}
