void ship_name(struct mtwist_state *mt, char *buffer, int buflen)
{
switch (mtwist_int(mt, 6)) {
case 0:
snprintf(buffer, buflen, "%s %s",
random_word(mt, SpaceWorthy, ARRAYSIZE(SpaceWorthy)),
random_word(mt, Animal, ARRAYSIZE(Animal)));
break;
case 1:
snprintf(buffer, buflen, "%s %s",
random_word(mt, Animal, ARRAYSIZE(Animal)),
random_word(mt, SpaceWorthy, ARRAYSIZE(SpaceWorthy)));
break;
case 2:
snprintf(buffer, buflen, "%s %s",
random_word(mt, ShipThing, ARRAYSIZE(ShipThing)),
random_word(mt, SpaceWorthy, ARRAYSIZE(SpaceWorthy)));
break;
case 3:
snprintf(buffer, buflen, "%s %s",
random_name(mt),
random_word(mt, SpaceWorthy, ARRAYSIZE(SpaceWorthy)));
break;
case 4:
snprintf(buffer, buflen, "%s %s",
random_word(mt, SpaceWorthy, ARRAYSIZE(SpaceWorthy)),
random_name(mt));
break;
default:
snprintf(buffer, buflen, "%s %s",
random_word(mt, SpaceWorthy, ARRAYSIZE(SpaceWorthy)),
random_word(mt, ShipThing, ARRAYSIZE(ShipThing)));
break;
}
}
static char *climate(struct mtwist_state *mt, enum planet_type ptype)
{
switch (ptype) {
case planet_type_gas_giant:
return random_word(mt, GasGiantClimate, ARRAYSIZE(GasGiantClimate));
case planet_type_earthlike:
return random_word(mt, Climate, ARRAYSIZE(Climate));
case planet_type_rocky:
return random_word(mt, RockyClimate, ARRAYSIZE(RockyClimate));
default:
break;
}
return random_word(mt, Climate, ARRAYSIZE(Climate));
}
int main( int argc, char const *argv[] )
{
// Used in old random method
// init();
// For the number of words guessed
int i;
// How long it took
struct timeval length;
// For seeding rand
gettimeofday( & length, NULL );
// Seed rand with call to srand
srand( length.tv_usec );
// Set values to zero, because this will
// now hold the differnece
length.tv_sec = 0;
length.tv_usec = 0;
// Set the starting index for new random method
starting_index = rand() % WORDS_LENGTH;
// Guess / type all the words
for ( i = 0; i < WORDS_LENGTH; ++i )
{
// Make the user type a random word
guess( words[ random_word() ], & length );
}
// Tell them how long they took
printf( "You took " );
print_time( & length );
printf( "\n" );
// Return clean exit
return 0;
}
static char *post_nominal_letters(struct mtwist_state *mt)
{
static char *nothing = "";
if (mtwist_int(mt, 100) < 85)
return nothing;
return random_word(mt, PostNominalLetters, ARRAYSIZE(PostNominalLetters));
}
int main(int argc,char **argv) {
int i;
int_random(time(NULL));
for(i=0;i<1000;i++) printf("%i\n",random_word()%1000);
return 0;
}
static void TAUS(PnlRng *rng,double *sample)
{
int i;
unsigned long b;
tausworthe_state *st;
/* Choice of the parameters to have ME-CF generators (cf L'Ecuyer) */
static const int k[3] = { 31, 29, 28};
static const int q[3] = { 13, 2 , 3};
static const int s[3] = { 12, 4 , 17};
static const int t[3] = { 19, 25, 11 }; /* t = k - s */
/* constant c : k bits to one and (L-k) bits to zero */
/* c[j]= 2^32 - 2^(L-k[j]) */
static const unsigned long c[3] = { 4294967294UL, 4294967288UL, 4294967280UL};
unsigned long v= 0;
const int L= 32;
st = (tausworthe_state *)(rng->state);
/* First call to the sequence. Initialisation */
if (rng->counter == 1)
{
/* initialisation of each generator */
for(i= 0; i< 3; i++)
{
/* The first k bits are chosen randomly */
st->u[i]= random_word(k[i], st);
/* The next L-k bits are initially fixed to zero */
st->u[i] = (st->u[i] << (L- k[i])) & BIT32_MASK;
/* Now they are computed with the recurrence on u */
b= (((st->u[i] << q[i]) & BIT32_MASK) ^ st->u[i]) >> k[i];
st->u[i] ^= b;
}
}
/* For each call to the sequence, computation of a new point */
for(i= 0; i< 3; i++)
{
/* Calculus of the next points for the 3 generators */
/* 6 steps explained by L'Ecuyer */
b = (((st->u[i]<<q[i]) & BIT32_MASK) ^ st->u[i]) >> t[i];
st->u[i] = (((st->u[i] & c[i]) << s[i]) & BIT32_MASK ) ^ b;
v ^= st->u[i]; /* Combination : XOR between the J generators */
}
/* Normalization by 2^32 */
*sample = v / 4294967296.0;
rng->counter++;
}
void new_level(Game *game)
{
char *word = strdup(random_word(game->all_words_array, MAX_WORD_LENGTH));
printf("word is %s\n", word);
shuffle(word);
printf("word is %s\n", word);
game->anagrams = find_all_anagrams(game->all_words_tree, word);
printf("%zu anagrams:\n", game->anagrams->count);
WordList **anagrams_by_length = malloc(sizeof(*anagrams_by_length) *
(MAX_WORD_LENGTH - 2));
sort_words(anagrams_by_length, game->anagrams);
for (size_t i = 0; i < MAX_WORD_LENGTH - 2; i++) {
printf("%zu: %zu words\n", i + 3, anagrams_by_length[i]->count);
for (size_t j = 0; j < anagrams_by_length[i]->count; j++)
printf("\t%s\n", GET_WORD(anagrams_by_length[i], j));
}
game->anagrams_by_length = anagrams_by_length;
game->column_sizes = compute_layout(game);
game->guessed_words =
make_word_list(game->anagrams->count, MAX_WORD_LENGTH + 1);
SDL_Color white = { 0xFF, 0xFF, 0xFF, 0xFF };
game->guessed_words_texture = render_empty_words(game, white);
SDL_DestroyTexture(game->message_box);
game->message_box = NULL;
game->chars_entered = 0;
memset(game->curr_input, 0, MAX_WORD_LENGTH + 1);
memcpy(game->remaining_chars, word, MAX_WORD_LENGTH + 1);
if (game->second_timer != 0)
SDL_RemoveTimer(game->second_timer);
game->second_timer = SDL_AddTimer(1000, timer_handler, game);
game->time_left = 180;
game->state = IN_LEVEL;
}
void robot_name(struct mtwist_state *mt, char *buffer, int buflen)
{
static char *robot_patterns[] = { "LNLN", "LNLL", "LNNL", "LLNL", "LLNN", "LNNN" };
char *pattern = random_word(mt, robot_patterns, ARRAYSIZE(robot_patterns));
int i;
char name[20];
memset(name, 0, sizeof(name));
for (i = 0; pattern[i]; i++) {
switch (pattern[i]) {
case 'L':
name[i] = random_letter(mt);
break;
case 'N':
name[i] = random_digit(mt);
break;
}
}
strncpy(buffer, name, buflen);
}
static char *bad_thing(struct mtwist_state *mt)
{
return random_word(mt, Bad_thing, ARRAYSIZE(Bad_thing));
}
static char *are(struct mtwist_state *m)
{
return random_word(m, Are, ARRAYSIZE(Are));
}
static char *nationality(struct mtwist_state *mt)
{
return random_word(mt, Nationality, ARRAYSIZE(Nationality));
}
static char *beast(struct mtwist_state *mt)
{
return random_word(mt, Beast, ARRAYSIZE(Beast));
}
static char *cease_fire(struct mtwist_state *mt)
{
return random_word(mt, Cease_fire, ARRAYSIZE(Cease_fire));
}
static char *climate(struct mtwist_state *mt)
{
return random_word(mt, Climate, ARRAYSIZE(Climate));
}
int
main (int argc, char **argv)
{
gmp_randstate_ptr rands;
unsigned long maxnbits, maxdbits, nbits, dbits;
mpz_t n, d, q, r, tz, junk;
mp_size_t maxnn, maxdn, nn, dn, clearn, i;
mp_ptr np, dup, dnp, qp, rp, junkp;
mp_limb_t t;
gmp_pi1_t dinv;
long count = COUNT;
mp_ptr scratch;
mp_limb_t ran;
mp_size_t alloc, itch;
mp_limb_t rran0, rran1, qran0, qran1;
TMP_DECL;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
maxdbits = MAX_DN;
maxnbits = MAX_NN;
tests_start ();
rands = RANDS;
mpz_init (n);
mpz_init (d);
mpz_init (q);
mpz_init (r);
mpz_init (tz);
mpz_init (junk);
maxnn = maxnbits / GMP_NUMB_BITS + 1;
maxdn = maxdbits / GMP_NUMB_BITS + 1;
TMP_MARK;
qp = TMP_ALLOC_LIMBS (maxnn + 2) + 1;
rp = TMP_ALLOC_LIMBS (maxnn + 2) + 1;
dnp = TMP_ALLOC_LIMBS (maxdn);
alloc = 1;
scratch = __GMP_ALLOCATE_FUNC_LIMBS (alloc);
for (test = -300; test < count; test++)
{
nbits = random_word (rands) % (maxnbits - GMP_NUMB_BITS) + 2 * GMP_NUMB_BITS;
if (test < 0)
dbits = (test + 300) % (nbits - 1) + 1;
else
dbits = random_word (rands) % (nbits - 1) % maxdbits + 1;
#if RAND_UNIFORM
#define RANDFUNC mpz_urandomb
#else
#define RANDFUNC mpz_rrandomb
#endif
do
RANDFUNC (d, rands, dbits);
while (mpz_sgn (d) == 0);
dn = SIZ (d);
dup = PTR (d);
MPN_COPY (dnp, dup, dn);
dnp[dn - 1] |= GMP_NUMB_HIGHBIT;
if (test % 2 == 0)
{
RANDFUNC (n, rands, nbits);
nn = SIZ (n);
ASSERT_ALWAYS (nn >= dn);
}
else
{
do
{
RANDFUNC (q, rands, random_word (rands) % (nbits - dbits + 1));
RANDFUNC (r, rands, random_word (rands) % mpz_sizeinbase (d, 2));
mpz_mul (n, q, d);
mpz_add (n, n, r);
nn = SIZ (n);
}
while (nn > maxnn || nn < dn);
}
ASSERT_ALWAYS (nn <= maxnn);
ASSERT_ALWAYS (dn <= maxdn);
mpz_urandomb (junk, rands, nbits);
junkp = PTR (junk);
np = PTR (n);
mpz_urandomb (tz, rands, 32);
t = mpz_get_ui (tz);
if (t % 17 == 0)
{
dnp[dn - 1] = GMP_NUMB_MAX;
dup[dn - 1] = GMP_NUMB_MAX;
}
switch ((int) t % 16)
{
case 0:
clearn = random_word (rands) % nn;
for (i = clearn; i < nn; i++)
np[i] = 0;
break;
case 1:
mpn_sub_1 (np + nn - dn, dnp, dn, random_word (rands));
break;
case 2:
mpn_add_1 (np + nn - dn, dnp, dn, random_word (rands));
break;
}
if (dn >= 2)
invert_pi1 (dinv, dnp[dn - 1], dnp[dn - 2]);
rran0 = random_word (rands);
rran1 = random_word (rands);
qran0 = random_word (rands);
qran1 = random_word (rands);
qp[-1] = qran0;
qp[nn - dn + 1] = qran1;
rp[-1] = rran0;
ran = random_word (rands);
if ((double) (nn - dn) * dn < 1e5)
{
/* Test mpn_sbpi1_div_qr */
if (dn > 2)
{
MPN_COPY (rp, np, nn);
if (nn > dn)
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_sbpi1_div_qr (qp, rp, nn, dnp, dn, dinv.inv32);
check_one (qp, rp, np, nn, dnp, dn, "mpn_sbpi1_div_qr", 0);
}
/* Test mpn_sbpi1_divappr_q */
if (dn > 2)
{
MPN_COPY (rp, np, nn);
if (nn > dn)
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_sbpi1_divappr_q (qp, rp, nn, dnp, dn, dinv.inv32);
check_one (qp, NULL, np, nn, dnp, dn, "mpn_sbpi1_divappr_q", 1);
}
/* Test mpn_sbpi1_div_q */
if (dn > 2)
{
MPN_COPY (rp, np, nn);
if (nn > dn)
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_sbpi1_div_q (qp, rp, nn, dnp, dn, dinv.inv32);
check_one (qp, NULL, np, nn, dnp, dn, "mpn_sbpi1_div_q", 0);
}
/* Test mpn_sb_div_qr_sec */
itch = 3 * nn + 4;
if (itch + 1 > alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_COPY (rp, np, nn);
if (nn >= dn)
MPN_COPY (qp, junkp, nn - dn + 1);
mpn_sb_div_qr_sec (qp, rp, nn, dup, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
check_one (qp, rp, np, nn, dup, dn, "mpn_sb_div_qr_sec", 0);
/* Test mpn_sb_div_r_sec */
itch = nn + 2 * dn + 2;
if (itch + 1 > alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_COPY (rp, np, nn);
mpn_sb_div_r_sec (rp, nn, dup, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
/* Note: Since check_one cannot cope with random-only functions, we
pass qp[] from the previous function, mpn_sb_div_qr_sec. */
check_one (qp, rp, np, nn, dup, dn, "mpn_sb_div_r_sec", 0);
}
/* Test mpn_dcpi1_div_qr */
if (dn >= 6 && nn - dn >= 3)
{
MPN_COPY (rp, np, nn);
if (nn > dn)
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_dcpi1_div_qr (qp, rp, nn, dnp, dn, &dinv);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0);
check_one (qp, rp, np, nn, dnp, dn, "mpn_dcpi1_div_qr", 0);
}
/* Test mpn_dcpi1_divappr_q */
if (dn >= 6 && nn - dn >= 3)
{
MPN_COPY (rp, np, nn);
if (nn > dn)
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_dcpi1_divappr_q (qp, rp, nn, dnp, dn, &dinv);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0);
check_one (qp, NULL, np, nn, dnp, dn, "mpn_dcpi1_divappr_q", 1);
}
/* Test mpn_dcpi1_div_q */
if (dn >= 6 && nn - dn >= 3)
{
MPN_COPY (rp, np, nn);
if (nn > dn)
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_dcpi1_div_q (qp, rp, nn, dnp, dn, &dinv);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0);
check_one (qp, NULL, np, nn, dnp, dn, "mpn_dcpi1_div_q", 0);
}
/* Test mpn_mu_div_qr */
if (nn - dn > 2 && dn >= 2)
{
itch = mpn_mu_div_qr_itch (nn, dn, 0);
if (itch + 1 > alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_COPY (qp, junkp, nn - dn);
MPN_ZERO (rp, dn);
rp[dn] = rran1;
qp[nn - dn] = mpn_mu_div_qr (qp, rp, np, nn, dnp, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0); ASSERT_ALWAYS (rp[dn] == rran1);
check_one (qp, rp, np, nn, dnp, dn, "mpn_mu_div_qr", 0);
}
/* Test mpn_mu_divappr_q */
if (nn - dn > 2 && dn >= 2)
{
itch = mpn_mu_divappr_q_itch (nn, dn, 0);
if (itch + 1 > alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_mu_divappr_q (qp, np, nn, dnp, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
check_one (qp, NULL, np, nn, dnp, dn, "mpn_mu_divappr_q", 4);
}
/* Test mpn_mu_div_q */
if (nn - dn > 2 && dn >= 2)
{
itch = mpn_mu_div_q_itch (nn, dn, 0);
if (itch + 1> alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_COPY (qp, junkp, nn - dn);
qp[nn - dn] = mpn_mu_div_q (qp, np, nn, dnp, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
check_one (qp, NULL, np, nn, dnp, dn, "mpn_mu_div_q", 0);
}
if (1)
{
itch = nn + 1;
if (itch + 1> alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
mpn_div_q (qp, np, nn, dup, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
check_one (qp, NULL, np, nn, dup, dn, "mpn_div_q", 0);
}
if (dn >= 2 && nn >= 2)
{
mp_limb_t qh;
/* mpn_divrem_2 */
MPN_COPY (rp, np, nn);
qp[nn - 2] = qp[nn-1] = qran1;
qh = mpn_divrem_2 (qp, 0, rp, nn, dnp + dn - 2);
ASSERT_ALWAYS (qp[nn - 2] == qran1);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - 1] == qran1);
qp[nn - 2] = qh;
check_one (qp, rp, np, nn, dnp + dn - 2, 2, "mpn_divrem_2", 0);
/* Missing: divrem_2 with fraction limbs. */
/* mpn_div_qr_2 */
qp[nn - 2] = qran1;
qh = mpn_div_qr_2 (qp, rp, np, nn, dup + dn - 2);
ASSERT_ALWAYS (qp[nn - 2] == qran1);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - 1] == qran1);
qp[nn - 2] = qh;
check_one (qp, rp, np, nn, dup + dn - 2, 2, "mpn_div_qr_2", 0);
}
}
__GMP_FREE_FUNC_LIMBS (scratch, alloc);
TMP_FREE;
mpz_clear (n);
mpz_clear (d);
mpz_clear (q);
mpz_clear (r);
mpz_clear (tz);
mpz_clear (junk);
tests_end ();
return 0;
}
int
main (int argc, char **argv)
{
gmp_randstate_ptr rands;
unsigned long maxnbits, maxdbits, nbits, dbits;
mpz_t n, d, tz;
mp_size_t maxnn, maxdn, nn, dn, clearn, i;
mp_ptr np, dp, qp, rp;
mp_limb_t rh;
mp_limb_t t;
mp_limb_t dinv;
int count = COUNT;
mp_ptr scratch;
mp_limb_t ran;
mp_size_t alloc, itch;
mp_limb_t rran0, rran1, qran0, qran1;
TMP_DECL;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
maxdbits = MAX_DN;
maxnbits = MAX_NN;
tests_start ();
rands = RANDS;
mpz_init (n);
mpz_init (d);
mpz_init (tz);
maxnn = maxnbits / GMP_NUMB_BITS + 1;
maxdn = maxdbits / GMP_NUMB_BITS + 1;
TMP_MARK;
qp = TMP_ALLOC_LIMBS (maxnn + 2) + 1;
rp = TMP_ALLOC_LIMBS (maxnn + 2) + 1;
alloc = 1;
scratch = __GMP_ALLOCATE_FUNC_LIMBS (alloc);
for (test = 0; test < count;)
{
nbits = random_word (rands) % (maxnbits - GMP_NUMB_BITS) + 2 * GMP_NUMB_BITS;
if (maxdbits > nbits)
dbits = random_word (rands) % nbits + 1;
else
dbits = random_word (rands) % maxdbits + 1;
#if RAND_UNIFORM
#define RANDFUNC mpz_urandomb
#else
#define RANDFUNC mpz_rrandomb
#endif
do
{
RANDFUNC (n, rands, nbits);
do
{
RANDFUNC (d, rands, dbits);
}
while (mpz_sgn (d) == 0);
np = PTR (n);
dp = PTR (d);
nn = SIZ (n);
dn = SIZ (d);
}
while (nn < dn);
dp[0] |= 1;
mpz_urandomb (tz, rands, 32);
t = mpz_get_ui (tz);
if (t % 17 == 0)
dp[0] = GMP_NUMB_MAX;
switch ((int) t % 16)
{
case 0:
clearn = random_word (rands) % nn;
for (i = 0; i <= clearn; i++)
np[i] = 0;
break;
case 1:
mpn_sub_1 (np + nn - dn, dp, dn, random_word (rands));
break;
case 2:
mpn_add_1 (np + nn - dn, dp, dn, random_word (rands));
break;
}
test++;
binvert_limb (dinv, dp[0]);
rran0 = random_word (rands);
rran1 = random_word (rands);
qran0 = random_word (rands);
qran1 = random_word (rands);
qp[-1] = qran0;
qp[nn - dn + 1] = qran1;
rp[-1] = rran0;
ran = random_word (rands);
if ((double) (nn - dn) * dn < 1e5)
{
if (nn > dn)
{
/* Test mpn_sbpi1_bdiv_qr */
MPN_ZERO (qp, nn - dn);
MPN_ZERO (rp, dn);
MPN_COPY (rp, np, nn);
rh = mpn_sbpi1_bdiv_qr (qp, rp, nn, dp, dn, -dinv);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0);
check_one (qp, rp + nn - dn, rh, np, nn, dp, dn, "mpn_sbpi1_bdiv_qr");
}
if (nn > dn)
{
/* Test mpn_sbpi1_bdiv_q */
MPN_COPY (rp, np, nn);
MPN_ZERO (qp, nn - dn);
mpn_sbpi1_bdiv_q (qp, rp, nn - dn, dp, MIN(dn,nn-dn), -dinv);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0);
check_one (qp, NULL, 0, np, nn, dp, dn, "mpn_sbpi1_bdiv_q");
}
}
if (dn >= 4 && nn - dn >= 2)
{
/* Test mpn_dcpi1_bdiv_qr */
MPN_COPY (rp, np, nn);
MPN_ZERO (qp, nn - dn);
rh = mpn_dcpi1_bdiv_qr (qp, rp, nn, dp, dn, -dinv);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0);
check_one (qp, rp + nn - dn, rh, np, nn, dp, dn, "mpn_dcpi1_bdiv_qr");
}
if (dn >= 4 && nn - dn >= 2)
{
/* Test mpn_dcpi1_bdiv_q */
MPN_COPY (rp, np, nn);
MPN_ZERO (qp, nn - dn);
mpn_dcpi1_bdiv_q (qp, rp, nn - dn, dp, MIN(dn,nn-dn), -dinv);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0);
check_one (qp, NULL, 0, np, nn, dp, dn, "mpn_dcpi1_bdiv_q");
}
if (nn > dn)
{
/* Test mpn_bdiv_qr */
itch = mpn_bdiv_qr_itch (nn, dn);
if (itch + 1 > alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_ZERO (qp, nn - dn);
MPN_ZERO (rp, dn);
rp[dn] = rran1;
rh = mpn_bdiv_qr (qp, rp, np, nn, dp, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0); ASSERT_ALWAYS (rp[dn] == rran1);
check_one (qp, rp, rh, np, nn, dp, dn, "mpn_bdiv_qr");
}
if (nn - dn < 2 || dn < 2)
continue;
/* Test mpn_mu_bdiv_qr */
itch = mpn_mu_bdiv_qr_itch (nn, dn);
if (itch + 1 > alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_ZERO (qp, nn - dn);
MPN_ZERO (rp, dn);
rp[dn] = rran1;
rh = mpn_mu_bdiv_qr (qp, rp, np, nn, dp, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
ASSERT_ALWAYS (rp[-1] == rran0); ASSERT_ALWAYS (rp[dn] == rran1);
check_one (qp, rp, rh, np, nn, dp, dn, "mpn_mu_bdiv_qr");
/* Test mpn_mu_bdiv_q */
itch = mpn_mu_bdiv_q_itch (nn, dn);
if (itch + 1 > alloc)
{
scratch = __GMP_REALLOCATE_FUNC_LIMBS (scratch, alloc, itch + 1);
alloc = itch + 1;
}
scratch[itch] = ran;
MPN_ZERO (qp, nn - dn + 1);
mpn_mu_bdiv_q (qp, np, nn - dn, dp, dn, scratch);
ASSERT_ALWAYS (ran == scratch[itch]);
ASSERT_ALWAYS (qp[-1] == qran0); ASSERT_ALWAYS (qp[nn - dn + 1] == qran1);
check_one (qp, NULL, 0, np, nn, dp, dn, "mpn_mu_bdiv_q");
}
__GMP_FREE_FUNC_LIMBS (scratch, alloc);
TMP_FREE;
mpz_clear (n);
mpz_clear (d);
mpz_clear (tz);
tests_end ();
return 0;
}
static char *traveling_accessory(struct mtwist_state *mt)
{
return random_word(mt, Traveling_Accessory,
ARRAYSIZE(Traveling_Accessory));
}
static char *character_title(struct mtwist_state *mt)
{
return random_word(mt, Title, ARRAYSIZE(Title));
}
static char *destroyed(struct mtwist_state *mt)
{
return random_word(mt, Destroyed, ARRAYSIZE(Destroyed));
}
static char *you_will_be(struct mtwist_state *mt)
{
return random_word(mt, You_will_be, ARRAYSIZE(You_will_be));
}
static char *get_lost(struct mtwist_state *mt)
{
return random_word(mt, Get_lost, ARRAYSIZE(Get_lost));
}
static char *bring_your(struct mtwist_state *mt)
{
return random_word(mt, Bring_Your, ARRAYSIZE(Bring_Your));
}
virtual void handle_mov(UByte opcode, size_t word_size) {
//
// Modify immediate only
//
switch (opcode) {
// [SKIP] Registers
case 0x88:
case 0x89:
case 0x8A:
case 0x8B:
case 0x8C:
case 0x8E:
{
UByte next;
_scanner.get(&next);
skip_modrm(next, word_size);
break;
}
// Immediate 8
case 0xC6:
{
UByte next;
UByte fault;
_scanner.get(&next);
skip_modrm(next, word_size);
fault = random_8();
_scanner.put(fault);
System.Print("FI: MOV(%2X): Change IMM to %.2X\n",
opcode, fault);
break;
}
// Immediate 16/32
case 0xC7:
{
UByte next;
UInt fault;
_scanner.get(&next);
skip_modrm(next, word_size);
fault = random_word(word_size);
_scanner.write(reinterpret_cast<const char*>(&fault),
word_size);
System.Print("FI: MOV(%.2X): Change IMM to %.8lX\n",
opcode, fault);
break;
}
// [SKIP] 'A' registers
case 0xA0:
case 0xA1:
case 0xA2:
case 0xA3:
{
skip_word(word_size);
break;
}
// Immediate
default:
{
if (0xB0 <= opcode && opcode <= 0xB7) {
UByte fault = random_8();
_scanner.put(fault);
System.Print("FI: MOV(%2X): Change IMM to %.2X\n",
opcode, fault);
}
else if (0xB8 <= opcode && opcode <= 0xBF) {
UInt fault = random_word(word_size);
_scanner.write(reinterpret_cast<const char*>(&fault),
word_size);
System.Print("FI: MOV(%2X): Change IMM to %.8lX\n",
opcode, fault);
}
else {
System.Print(System.WARN, "Unknown opcode\n");
}
}
}
}
static char *like(struct mtwist_state *mt)
{
return random_word(mt, Like, ARRAYSIZE(Like));
}
struct names *make_fontnames( ) {
struct names *font_names = (struct names *) malloc( sizeof( struct names ) );
/* Seed name generator with dictionary file if present in standard locations.
*/
if ( dict_file == NULL )
dict_file = mmap_file( "/usr/share/dict/words" );
if ( dict_file == NULL )
dict_file = mmap_file( "/usr/share/words" );
if ( dict_file != NULL )
dict_lines = count_lines( dict_file );
char *foundryVendorID = random_majuscule_characters( 4 );
const char *copyrightNotice = "All rights to this work have been "
"relinquished. The work is in the Public "
"Domain.";
const char *fontFamilyStyle = "Regular";
int familyNameWords = rand( ) % 3 + 1;
int fontFamilyNamelen = WORDLEN_MAX * familyNameWords + 1;
char *fontFamilyName = malloc( fontFamilyNamelen );
int postscriptNamelen =
WORDLEN_MAX * familyNameWords + 1 + strlen( fontFamilyStyle );
char *postscriptName = malloc( postscriptNamelen );
fontFamilyName[0] = '\0';
postscriptName[0] = '\0';
for ( int i = 0; i < familyNameWords; i++ ) {
char *word = random_word( );
strncat( fontFamilyName, word, fontFamilyNamelen );
strncat( postscriptName, word, postscriptNamelen );
free( word );
if ( ( i + 1 ) < familyNameWords ) {
strncat( fontFamilyName, " ", fontFamilyNamelen );
}
}
strncat( postscriptName, fontFamilyStyle, postscriptNamelen );
if ( dict_file != NULL )
free_positions( dict_lines );
char *versionString = "Version 1.000";
int fullFontNamelen =
strlen( fontFamilyName ) + strlen( fontFamilyStyle ) + 2;
char *fullFontName = malloc( fullFontNamelen );
fullFontName[0] = '\0';
strncat( fullFontName, fontFamilyName, fullFontNamelen );
strncat( fullFontName, " ", fullFontNamelen );
strncat( fullFontName, fontFamilyStyle, fullFontNamelen );
int uniqueFontNamelen = strlen( foundryVendorID ) + strlen( fullFontName ) +
strlen( versionString ) + 3;
char *uniqueFontName = malloc( uniqueFontNamelen );
uniqueFontName[0] = '\0';
strncat( uniqueFontName, foundryVendorID, uniqueFontNamelen );
strncat( uniqueFontName, ";", uniqueFontNamelen );
strncat( uniqueFontName, fullFontName, uniqueFontNamelen );
strncat( uniqueFontName, ";", uniqueFontNamelen );
strncat( uniqueFontName, versionString, uniqueFontNamelen );
font_names->copyrightNotice = copyrightNotice;
font_names->fontFamilyName = fontFamilyName;
font_names->fontFamilyStyle = fontFamilyStyle;
font_names->uniqueFontName = uniqueFontName;
font_names->versionString = versionString;
font_names->fullFontName = fullFontName;
font_names->postscriptName = postscriptName;
font_names->foundryVendorID = foundryVendorID;
return font_names;
}
static char *adjective(struct mtwist_state *mt)
{
return random_word(mt, Adjective, ARRAYSIZE(Adjective));
}
static char *you(struct mtwist_state *mt)
{
return random_word(mt, You, ARRAYSIZE(You));
}
static char *be_advised(struct mtwist_state *mt)
{
return random_word(mt, Be_advised, ARRAYSIZE(Be_advised));
}
void game()
{
unsigned int choice = 0;
int hires = 0, y = 0, i, life = 13, flg = 0, donth = 0;
char guess;
char cens[20] = { '\0' };
char alph[25] = { '\0' };
clear();
keypad(stdscr, true);
curs_set(0);
while (!flg) {
unsigned i;
clear();
printw("Выберите тему:\n");
for (i = 0; i < 5; i++) {
if (i == choice)
addch('>');
else
addch(' ');
printw("%s\n", themes[i]);
}
attron(A_REVERSE);
mvwprintw(stdscr, getmaxy(stdscr) - 1, 0,
"Нажмите ENTER для подтверждения, стрелки вверх/вниз для выбора");
attroff(A_REVERSE);
switch (getch()) {
case KEY_UP:
if (choice)
choice--;
break;
case KEY_DOWN:
if (choice != 4)
choice++;
break;
case '\n':
flg++;
break;
}
}
random_word(word, choice);
while (strcmp(cens, word) && life > 0 && guess != 27) {
if (getmaxx(stdscr) >= 130 && getmaxy(stdscr) >= 40) {
hires = 1;
y = LINES / 2 - 3;
} else {
hires = 0;
y = 0;
}
clear();
life = asteriks(word, cens, guess, life, donth); //обработчик от Мариши
mvprintw(y, 0, "Выбранная тема: %s\n", themes[choice]);
mvprintw(y + 1, 0, "Ваше слово сейчас: %s\n", cens);
jizi(life, hires); //жизни от Дани
attron(A_REVERSE);
mvwprintw(stdscr, getmaxy(stdscr) - 1, 0,
"Нажмите ENTER для подтверждения, ESC для выхода");
attroff(A_REVERSE);
if (hires)
risunok_hd(life + 1); //рисунок от Дани
else
risunok(life + 1); //рисунок от Дани
guess = input(hires); //ввод от Ксюни
donth = check(guess, alph);
}
clear();
printw("Загаданное слово было: %s\n", word);
printw("Осталось жизней: %d\n", life);
if ((life > 0) && (guess != 27))
win();
else
lose();
attron(A_REVERSE);
mvwprintw(stdscr, getmaxy(stdscr) - 1, 0,
"Нажмите любую клавишу для продолжения");
attroff(A_REVERSE);
cbreak();
getch();
clear();
return;
}
static char *action(struct mtwist_state *mt)
{
return random_word(mt, Action, ARRAYSIZE(Action));
}
