void sample(void * arg, ulong count)
{
mp_limb_t n, d, r = 0;
double dpre;
ulong i;
mp_ptr array = (mp_ptr) flint_malloc(1024*sizeof(mp_limb_t));
flint_rand_t state;
flint_randinit(state);
for (i = 0; i < count; i++)
{
int j;
d = n_randtest(state);
if (d == 0UL) d++;
dpre = n_precompute_inverse(d);
for (j = 0; j < 1024; j++)
{
array[j] = n_randtest(state);
}
prof_start();
for (j = 0; j < 10000; j++)
{
r += n_mod2_precomp(array[j&1023], d, dpre);
}
prof_stop();
}
if (r == 0) abort();
flint_randclear(state);
flint_free(array);
}
mp_limb_t n_primitive_root_prime_prefactor(mp_limb_t p, n_factor_t * factors)
{
slong i;
int found;
mp_limb_t result, a, pm1;
double pinv;
if (p == 2)
{
return 1;
}
pm1 = p - 1;
pinv = n_precompute_inverse(p);
for (a = 2; a < p; a++)
{
found = 1;
for (i = 0; i < factors->num; i++)
{
result = n_powmod_precomp(a, pm1 / factors->p[i], p, pinv);
if (result == 1)
{
found = 0;
break;
}
}
if (found)
{
return a;
}
}
flint_printf("Exception (n_primitive_root_prime_prefactor). root not found.\n");
abort();
}
int
n_is_probabprime_fibonacci(mp_limb_t n)
{
mp_limb_t m;
n_pair_t V;
if (FLINT_ABS((mp_limb_signed_t) n) <= 3UL)
{
if (n >= 2UL)
return 1;
return 0;
}
m = (n - n_jacobi(5L, n)) / 2; /* cannot overflow
as (5/n) = 0 for n = 2^64-1 */
if (FLINT_BIT_COUNT(n) <= FLINT_D_BITS)
{
double npre = n_precompute_inverse(n);
V = fchain_precomp(m, n, npre);
return (n_mulmod_precomp(n - 3UL, V.x, n, npre) ==
n_mulmod_precomp(2UL, V.y, n, npre));
}
else
{
mp_limb_t ninv = n_preinvert_limb(n);
V = fchain2_preinv(m, n, ninv);
return (n_mulmod2_preinv(n - 3UL, V.x, n, ninv) ==
n_mulmod2_preinv(2UL, V.y, n, ninv));
}
}
void padic_ctx_init(padic_ctx_t ctx, const fmpz_t p, long N,
enum padic_print_mode mode)
{
fmpz_init(ctx->p);
fmpz_set(ctx->p, p);
ctx->N = N;
ctx->pinv = (!COEFF_IS_MPZ(*p)) ? n_precompute_inverse(fmpz_get_ui(p)) : 0;
if (N > 0)
{
long i, len;
ctx->min = FLINT_MAX(1, N - 10);
ctx->max = N + 10;
len = ctx->max - ctx->min;
ctx->pow = _fmpz_vec_init(len);
fmpz_pow_ui(ctx->pow, p, ctx->min);
for (i = 1; i < len; i++)
fmpz_mul(ctx->pow + i, ctx->pow + (i - 1), p);
}
else
{
ctx->min = 0;
ctx->max = 0;
ctx->pow = NULL;
}
ctx->mode = mode;
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mulmod_precomp....");
fflush(stdout);
for (i = 0; i < 100000 * flint_test_multiplier(); i++)
{
mp_limb_t a, b, d, r1, r2, p1, p2, dinv;
double dpre;
mp_limb_t bits = n_randint(state, FLINT_D_BITS) + 1;
d = n_randtest_bits(state, bits);
a = n_randtest(state) % d;
b = n_randtest(state) % d;
dpre = n_precompute_inverse(d);
r1 = n_mulmod_precomp(a, b, d, dpre);
umul_ppmm(p1, p2, a, b);
dinv = n_preinvert_limb(d);
r2 = n_ll_mod_preinv(p1, p2, d, dinv);
result = (r1 == r2);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = %wu, b = %wu, d = %wu, dinv = %f\n", a, b, d, dpre);
flint_printf("r1 = %wu, r2 = %wu\n", r1, r2);
abort();
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("mod_precomp....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 1000000; i++)
{
mp_limb_t bits, d, n, r1, r2;
double dpre;
bits = n_randint(state, FLINT_D_BITS) + 1;
d = n_randbits(state, bits);
if (bits <= (FLINT_BITS/2)) n = n_randint(state, d*d);
else n = n_randtest(state);
dpre = n_precompute_inverse(d);
r1 = n_mod_precomp(n, d, dpre);
r2 = n%d;
result = (r1 == r2);
if (!result)
{
printf("FAIL:\n");
printf("n = %lu, d = %lu, dinv = %f\n", n, d, dpre);
printf("r1 = %lu, r2 = %lu\n", r1, r2);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("mod2_precomp....");
fflush(stdout);
for (i = 0; i < 1000000; i++)
{
mp_limb_t d, n, r1, r2;
double dpre;
d = n_randtest(state);
if (d == 0UL) d++;
n = n_randtest(state);
dpre = n_precompute_inverse(d);
r1 = n_mod2_precomp(n, d, dpre);
r2 = n%d;
result = (r1 == r2);
if (!result)
{
printf("FAIL:\n");
printf("n = %lu, d = %lu, dpre = %f\n", n, d, dpre);
printf("r1 = %lu, r2 = %lu\n", r1, r2);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
static void precompute_nu(fmpz *nu, long *v, long M,
const long *C, long lenC, long p, long N)
{
const long R = M / p;
const long N2 = N + (M / (p - 1));
fmpz_t P, PN2, t;
padic_inv_t S;
double pinv;
long i, j;
fmpz_init_set_ui(P, p);
fmpz_init(PN2);
fmpz_pow_ui(PN2, P, N2);
fmpz_init(t);
/*
Step 1. Compute $i! mod p^{N_2}$ where $N_2 \geq N + \max \ord_p (i!)$
Step 2. Invert the unit part of $i!$ modulo $p^N$
*/
fmpz_one(nu + 0);
for (i = 1; i <= R; i++)
{
fmpz_mul_ui(nu + i, nu + (i - 1), i);
fmpz_mod(nu + i, nu + i, PN2);
}
/* Let j denote the greatest index s.t. nu[j] has been computed */
for (j = R, i = R + 1; i <= M; i++)
{
if (_bsearch(C, 0, lenC, i % p) != -1)
{
fmpz_mod_rfac_uiui(t, j + 1, i - j, PN2);
fmpz_mul(nu + i, nu + j, t);
fmpz_mod(nu + i, nu + i, PN2);
j = i;
}
}
_padic_inv_precompute(S, P, N);
pinv = n_precompute_inverse(p);
v[0] = 0;
for (i = 1; i <= R; i++)
{
v[i] = - _fmpz_remove(nu + i, P, pinv);
_padic_inv_precomp(nu + i, nu + i, S);
}
for (i = R + 1; i <= M; i++)
{
if (_bsearch(C, 0, lenC, i % p) != -1)
{
v[i] = - _fmpz_remove(nu + i, P, pinv);
_padic_inv_precomp(nu + i, nu + i, S);
}
}
fmpz_clear(P);
fmpz_clear(PN2);
fmpz_clear(t);
_padic_inv_clear(S);
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("powmod_precomp....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
mp_limb_t a, d, r1, r2, bits;
mpz_t a_m, d_m, r2_m;
mp_limb_signed_t exp;
double dpre;
mpz_init(a_m);
mpz_init(d_m);
mpz_init(r2_m);
bits = n_randint(state, FLINT_D_BITS) + 1;
d = n_randbits(state, bits);
do
{
a = n_randint(state, d);
} while (n_gcd(d, a) != 1UL);
exp = n_randtest(state);
dpre = n_precompute_inverse(d);
r1 = n_powmod_precomp(a, exp, d, dpre);
mpz_set_ui(a_m, a);
mpz_set_ui(d_m, d);
if (exp < 0L)
{
mpz_powm_ui(r2_m, a_m, -exp, d_m);
mpz_invert(r2_m, r2_m, d_m);
} else
mpz_powm_ui(r2_m, a_m, exp, d_m);
r2 = mpz_get_ui(r2_m);
result = (r1 == r2);
if (!result)
{
printf("FAIL:\n");
printf("a = %lu, exp = %ld, d = %lu\n", a, exp, d);
printf("r1 = %lu, r2 = %lu\n", r1, r2);
abort();
}
mpz_clear(a_m);
mpz_clear(d_m);
mpz_clear(r2_m);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
