int main(void)
{
mp_limb_t n;
int j;
FLINT_TEST_INIT(state);
flint_printf("factorial_mod2_preinv....");
fflush(stdout);
for (n = 0; n < 100 * flint_test_multiplier(); n++)
{
mp_limb_t p, pinv, x, y;
for (j = 0; j < 10; j++)
{
p = n_randtest_not_zero(state);
pinv = n_preinvert_limb(p);
x = n_factorial_mod2_preinv(n, p, pinv);
y = n_factorial_mod2_foolproof(n, p, pinv);
if (x != y)
{
flint_printf("FAIL:\n");
flint_printf("n = %wu\np = %wu\nx = %wu\ny = %wu\n", n, p, x, y);
abort();
}
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
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 sample(void * arg, ulong count)
{
mp_limb_t n, d, dinv, r = 0, norm;
double dpre;
info_t * info = (info_t *) arg;
mp_bitcnt_t bits = info->bits;
ulong type = info->type;
ulong i;
flint_rand_t state;
flint_randinit(state);
mp_ptr arr = (mp_ptr) malloc(1024*sizeof(mp_limb_t));
mp_ptr arr2 = (mp_ptr) malloc(1024*sizeof(mp_limb_t));
for (i = 0; i < count; i++)
{
int j;
d = n_randbits(state, bits);
if (d == 0UL) d++;
dinv = n_preinvert_limb(d);
for (j = 0; j < 1024; j++)
{
arr[j] = n_randbits(state, FLINT_BITS);
arr2[j] = n_randint(state, n);
}
switch (type)
{
case 1:
prof_start();
for (mp_size_t j = 0; j < 10000UL; j++)
{
r += n_lll_mod_preinv(arr2[j&1023], arr[j&1023], arr[(j+1)&1023], d, dinv);
}
prof_stop();
break;
}
}
if (r == 9879875897UL) abort();
flint_randclear(state);
free(arr);
free(arr2);
}
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;
}
mp_limb_t fmpz_poly_evaluate_mod(const fmpz_poly_t poly, mp_limb_t a,
mp_limb_t n)
{
if (poly->length == 0)
return 0;
if (a == 0)
{
mp_limb_t res;
res = fmpz_fdiv_ui(poly->coeffs, n);
return res;
}
else
{
mp_limb_t ninv;
ninv = n_preinvert_limb(n);
return _fmpz_poly_evaluate_mod(poly->coeffs, poly->length, a, n, ninv);
}
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("lll_mod_preinv....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 1000000; i++)
{
mp_limb_t d, dinv, nh, nm, nl, r1, r2, m;
d = n_randtest_not_zero(state);
m = n_randtest(state);
nh = n_randint(state, d);
nm = n_randtest(state);
nl = n_randtest(state);
dinv = n_preinvert_limb(d);
r2 = n_lll_mod_preinv(nh, nm, nl, d, dinv);
nm = n_ll_mod_preinv(nh, nm, d, dinv);
r1 = n_ll_mod_preinv(nm, nl, d, dinv);
result = (r1 == r2);
if (!result)
{
printf("FAIL:\n");
printf("nh = %lu, nm = %ld, nl = %lu, d = %lu, dinv = %lu\n", nh, nm, nl, d, dinv);
printf("r1 = %lu, r2 = %lu\n", r1, r2);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
void qsieve_ll_compute_A(qs_t qs_inf)
{
long i;
do
{
try_compute_A(qs_inf);
} while (((qs_inf->A > P_GOODNESS * qs_inf->target_A
|| qs_inf->A < qs_inf->target_A / P_GOODNESS) && qs_inf->s > 2)
|| (((qs_inf->A > P_GOODNESS2 * qs_inf->target_A
|| qs_inf->A < qs_inf->target_A / P_GOODNESS2) && qs_inf->s == 2)));
#if QS_DEBUG > 1
printf("A = %ld, target A = %ld\n", qs_inf->A, qs_inf->target_A);
#endif
for (i = 0; i < qs_inf->s; i++)
{
mp_limb_t p = qs_inf->factor_base[qs_inf->A_ind[i]].p;
qs_inf->inv_p2[i] = n_preinvert_limb(p*p);
}
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mod2_preinv....");
fflush(stdout);
for (i = 0; i < 100000 * flint_test_multiplier(); i++)
{
mp_limb_t d, dinv, n, r1, r2;
d = n_randtest_not_zero(state);
n = n_randtest(state);
dinv = n_preinvert_limb(d);
r1 = n_mod2_preinv(n, d, dinv);
r2 = n%d;
result = (r1 == r2);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n = %wu, d = %wu, dinv = %wu\n", n, d, dinv);
flint_printf("r1 = %wu, r2 = %wu\n", r1, r2);
abort();
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
flint_rand_t state;
slong nmax, n, bound, count;
mp_limb_t p, pinv, m1, m2;
nmod_poly_t A;
flint_printf("rev....");
fflush(stdout);
flint_randinit(state);
bound = 100000;
p = n_nextprime(UWORD(1) << (FLINT_BITS - 1), 0);
pinv = n_preinvert_limb(p);
nmod_poly_init(A, p);
nmod_poly_set_coeff_ui(A, 1, 1);
nmod_poly_exp_series(A, A, bound);
nmod_poly_shift_right(A, A, 1);
nmod_poly_inv_series(A, A, bound);
m1 = 1;
for (n = 0; n < A->length; n++)
{
A->coeffs[n] = n_mulmod2_preinv(A->coeffs[n], m1, p, pinv);
m1 = n_mulmod2_preinv(m1, n + 1, p, pinv);
}
for (nmax = 0; nmax < bound; nmax = 1.5 * nmax + 2)
{
fmpz_t numer, denom;
bernoulli_rev_t iter;
fmpz_init(numer);
fmpz_init(denom);
nmax += (nmax % 2);
bernoulli_rev_init(iter, nmax);
if (nmax < 8000)
count = 4000;
else
count = 100;
/* flint_printf("nmax = %wd, count = %wd\n", nmax, count); */
for (n = nmax; n >= 0 && count > 0; n -= 2, count--)
{
bernoulli_rev_next(numer, denom, iter);
m1 = fmpz_fdiv_ui(numer, p);
m2 = fmpz_fdiv_ui(denom, p);
m2 = n_invmod(m2, p);
m1 = n_mulmod2_preinv(m1, m2, p, pinv);
m2 = nmod_poly_get_coeff_ui(A, n);
if (m1 != m2)
{
flint_printf("FAIL:\n");
flint_printf("nmax = %wd, n = %wd\n", nmax, n);
flint_printf("m1 = %wu mod %wu\n", m1, p);
flint_printf("m2 = %wu mod %wu\n", m2, p);
abort();
}
}
bernoulli_rev_clear(iter);
fmpz_clear(numer);
fmpz_clear(denom);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
mp_limb_t n_sqrtmod(mp_limb_t a, mp_limb_t p)
{
slong i, r, m;
mp_limb_t p1, k, b, g, bpow, gpow, res;
mp_limb_t pinv;
if (a <= 1)
{
return a;
}
pinv = n_preinvert_limb(p);
if (n_jacobi_unsigned(a, p) == -1)
return 0;
if ((p & UWORD(3)) == 3)
{
return n_powmod2_ui_preinv(a, (p + 1) / 4, p, pinv);
}
r = 0;
p1 = p - 1;
do {
p1 >>= UWORD(1);
r++;
} while ((p1 & UWORD(1)) == 0);
b = n_powmod2_ui_preinv(a, p1, p, pinv);
for (k = 2; ; k++)
{
if (n_jacobi_unsigned(k, p) == -1) break;
}
g = n_powmod2_ui_preinv(k, p1, p, pinv);
res = n_powmod2_ui_preinv(a, (p1 + 1) / 2, p, pinv);
while (b != 1)
{
bpow = b;
m = 0;
do
{
bpow = n_mulmod2_preinv(bpow, bpow, p, pinv);
m++;
} while (m < r && bpow != 1);
gpow = g;
for (i = 1; i < r - m; i++)
{
gpow = n_mulmod2_preinv(gpow, gpow, p, pinv);
}
res = n_mulmod2_preinv(res, gpow, p, pinv);
g = n_mulmod2_preinv(gpow, gpow, p, pinv);
b = n_mulmod2_preinv(b, g, p, pinv);
r = m;
}
return res;
}
void fmpz_powm_ui(fmpz_t f, const fmpz_t g, ulong e, const fmpz_t m)
{
if (fmpz_sgn(m) <= 0)
{
printf("Exception (fmpz_powm_ui). Modulus is less than 1.\n");
abort();
}
if (fmpz_is_one(m))
{
fmpz_zero(f);
}
else if (e == 0)
{
fmpz_one(f);
}
else /* e != 0, m > 0 */
{
fmpz g2 = *g;
fmpz m2 = *m;
if (!COEFF_IS_MPZ(m2)) /* m is small */
{
if (!COEFF_IS_MPZ(g2)) /* g is small */
{
mp_limb_t minv = n_preinvert_limb(m2);
_fmpz_demote(f);
if (g2 >= 0)
{
g2 = n_mod2_preinv(g2, m2, minv);
*f = n_powmod2_preinv(g2, e, m2, minv);
}
else
{
g2 = n_mod2_preinv(-g2, m2, minv);
*f = n_powmod2_preinv(g2, e, m2, minv);
if ((e & 1UL))
*f = n_negmod(*f, m2);
}
}
else /* g is large */
{
__mpz_struct *ptr = _fmpz_promote(f);
mpz_t m3;
mpz_init_set_ui(m3, m2);
mpz_powm_ui(ptr, COEFF_TO_PTR(g2), e, m3);
mpz_clear(m3);
_fmpz_demote_val(f);
}
}
else /* m is large */
{
if (!COEFF_IS_MPZ(g2)) /* g is small */
{
__mpz_struct *ptr = _fmpz_promote(f);
mpz_t g3;
mpz_init_set_si(g3, g2);
mpz_powm_ui(ptr, g3, e, COEFF_TO_PTR(m2));
mpz_clear(g3);
_fmpz_demote_val(f);
}
else /* g is large */
{
__mpz_struct *ptr = _fmpz_promote(f);
mpz_powm_ui(ptr, COEFF_TO_PTR(g2), e, COEFF_TO_PTR(m2));
_fmpz_demote_val(f);
}
}
}
}
void
nmod_poly_init2(nmod_poly_t poly, mp_limb_t n, long alloc)
{
nmod_poly_init2_preinv(poly, n, n_preinvert_limb(n), alloc);
}