Example #1
0
/*
* Modulo Operator
*/
word BigInt::operator%=(word mod)
{
    if(mod == 0)
        throw BigInt::DivideByZero();

    if(is_power_of_2(mod))
    {
        word result = (word_at(0) & (mod - 1));
        clear();
        grow_to(2);
        m_reg[0] = result;
        return result;
    }

    word remainder = 0;

    for(size_t j = sig_words(); j > 0; --j)
        remainder = bigint_modop(remainder, word_at(j-1), mod);
    clear();
    grow_to(2);

    if(remainder && sign() == BigInt::Negative)
        m_reg[0] = mod - remainder;
    else
        m_reg[0] = remainder;

    set_sign(BigInt::Positive);

    return word_at(0);
}
Example #2
0
/**
 * sieves all primes in the given interval, and layer (cache optimization)
 * for the given candidates array
 */
static void sieve_from_to(sieve_t  *const   candidates,
                          uint32_t *const   multipliers,
                          const    uint32_t start,
                          const    uint32_t end,
                          const    uint32_t layer) {

  /* wipe the array */
  memset(candidates + word_index(start), 0, cache_bytes);

  uint32_t i;
  for (i = min_prime_index; i < max_prime_index; i++) {

    /* current prime */
    const uint32_t prime = primes[i];
    
    /* current factor (from the inverse calculation) */
    uint32_t factor = multipliers[i * layers + layer];

    /* adjust factor for the given range */
    if (factor < start)
      factor += (start - factor + prime - 1) / prime * prime;

    /* progress the given range of the sieve */
    for (; factor < end; factor += prime) {

      /* set sieve[factor] = composite */
      word_at(candidates, factor) |= bit_word(factor);
    }

    /* save the factor for the next round */
    multipliers[i * layers + layer] = factor;
  }
}
Example #3
0
/*************************************************
* Count how many bits are being used             *
*************************************************/
u32bit BigInt::bits() const
   {
   if(sig_words() == 0)
      return 0;

   u32bit full_words = sig_words() - 1, top_bits = MP_WORD_BITS;
   word top_word = word_at(full_words), mask = MP_WORD_TOP_BIT;

   while(top_bits && ((top_word & mask) == 0))
      { mask >>= 1; top_bits--; }

   return (full_words * MP_WORD_BITS + top_bits);
   }
static void querydialogdata( LPCSTR data, dialogdata_t * result )
{
	WORD *p = (WORD *)data;
	unsigned long rstyle = dword_at(p);
	int dialogex=0;

	p += 2;

	if (rstyle == 0xffff0001)
	{
		p+=4;     /* skip 8 bytes */
		rstyle=dword_at(p);
		p+=2;
		dialogex=1;
	}else
			p+=2; /* NOT dialogex */

	p+=3;
	/* get the x, y sizes out */
	result->cx = word_at(p);
	p++;
	result->cy = word_at(p);
	p++;

	// Skip menu
	switch(word_at(p))
	{
	case 0x0000: // no menu name
		result->has_menu=0;
		p++;
		break;
	case 0xffff: // has menu
		result->has_menu=1;
		p += 2;
		break;
	default:     // has menu
		result->has_menu=1;
		p+=wcslen((LPCWSTR)p)+1;
		break;
	}

	// skip class name
	switch(word_at(p))
	{
	case 0x0000:
		p++;
		break;
	case 0xffff:
		p += 2;
		break;
	default:
		p+=wcslen((LPCWSTR)p)+1;
		break;
	}

	// skip the caption
	p+=wcslen((LPCWSTR)p)+1;

	// get the font name

	if (rstyle & DS_SETFONT)
	{
		result->pt = word_at(p); p++;
		if (dialogex)
		{
			result->weight = word_at(p); p++;
			result->italic = LOBYTE(word_at(p)); p++;
		}else
		{
			result->weight = FW_DONTCARE;
			result->italic = FALSE;
		}
		result->faceName = (LPCWSTR)p;
		p += wcslen( result->faceName ) + 1;
	}else
	{
		result->faceName=L"Tahoma"; // TODO: put system font name here
		result->pt=8; // TODO
		result->weight=FW_NORMAL; // TODO
		result->italic=FALSE; // TODO
	}
}