void
fmpz_mat_randajtai(fmpz_mat_t mat, flint_rand_t state, double alpha)
{
long r, c, i, j, d;
fmpz_t tmp;
r = mat->r;
c = mat->c;
d = r;
if (c != r)
{
printf("Exception: fmpz_mat_ajtai called on an ill-formed matrix\n");
abort();
}
fmpz_init(tmp);
for (i = 0; i < d; i++)
{
mp_bitcnt_t bits = (mp_bitcnt_t) pow((double) (2 * d - i), alpha);
fmpz_one(tmp);
fmpz_mul_2exp(tmp, tmp, bits);
fmpz_sub_ui(tmp, tmp, 1);
fmpz_randm(mat->rows[i] + i, state, tmp);
fmpz_add_ui(mat->rows[i] + i, mat->rows[i] + i, 2);
fmpz_fdiv_q_2exp(mat->rows[i] + i, mat->rows[i] + i, 1);
for (j = i + 1; j <= d; j++)
{
fmpz_randm(mat->rows[j] + i, state, tmp);
if (n_randint(state, 2))
fmpz_neg(mat->rows[j] + i, mat->rows[j] + i);
fmpz_zero(mat->rows[i] + j);
}
}
fmpz_clear(tmp);
}
void
fmpz_mat_randajtai(fmpz_mat_t mat, flint_rand_t state, double alpha)
{
const slong c = mat->c, r = mat->r, d = r;
slong i, j;
fmpz_t tmp;
if (c != r)
{
flint_printf("Exception (fmpz_mat_ajtai): Non-square matrix.\n");
abort();
}
fmpz_init(tmp);
for (i = 0; i < d; i++)
{
mp_bitcnt_t bits = (mp_bitcnt_t) pow((double) (2 * d - i), alpha);
fmpz_one(tmp);
fmpz_mul_2exp(tmp, tmp, bits);
fmpz_sub_ui(tmp, tmp, 1);
fmpz_randm(mat->rows[i] + i, state, tmp);
fmpz_add_ui(mat->rows[i] + i, mat->rows[i] + i, 2);
fmpz_fdiv_q_2exp(mat->rows[i] + i, mat->rows[i] + i, 1);
for (j = i + 1; j <= d; j++)
{
fmpz_randm(mat->rows[j] + i, state, tmp);
if (n_randint(state, 2))
fmpz_neg(mat->rows[j] + i, mat->rows[j] + i);
fmpz_zero(mat->rows[i] + j);
}
}
fmpz_clear(tmp);
}
void padic_poly_randtest_val(padic_poly_t f, flint_rand_t state,
slong val, slong len, const padic_ctx_t ctx)
{
const slong N = padic_poly_prec(f);
if (len == 0)
return;
if (val >= N)
{
padic_poly_zero(f);
}
else
{
slong i;
fmpz_t pow;
int alloc;
f->val = val;
padic_poly_fit_length(f, len);
alloc = _padic_ctx_pow_ui(pow, N - f->val, ctx);
for (i = 0; i < len; i++)
fmpz_randm(f->coeffs + i, state, pow);
if (alloc)
fmpz_clear(pow);
for (i = 0; i < len; i++)
if (!fmpz_divisible(f->coeffs + i, ctx->p))
break;
if (i == len)
fmpz_one(f->coeffs + n_randint(state, len));
_padic_poly_set_length(f, len);
_padic_poly_normalise(f);
padic_poly_reduce(f, ctx);
}
}
void
test0(slong b)
{
fmpz_t M; fmpz_init_set_ui(M,1);
fmpz_mul_2exp(M,M,(ulong)b);
test1_ui(b,M,0);
test1_ui(b,M,1);
test1_ui(b,M,(mp_limb_t)-1);
test1(b,M,M); // M
fmpz_t n; fmpz_init_set(n,M);
fmpz_add_ui(n,M,1);
test1(b,M,n); // M+1
fmpz_sub_ui(n,M,1);
test1(b,M,n); // M-1
slong i;
fmpz_t m; fmpz_init(m);
fmpz_t Mhalf; fmpz_init(Mhalf);
fmpz_fdiv_q_2exp(Mhalf,M,1);
for(i=100;i--;)
{
fmpz_randm(m,rst,n); // m = random(M-1)
test1(b,M,m);
fmpz_add(m,m,Mhalf); // m+M/2
test1(b,M,m);
}
fmpz_mul_2exp(m,M,1);
test1(b,M,m); // M<<1
fmpz_mul_2exp(m,m,1);
test1(b,M,m); // M<<2
fmpz_mul_2exp(m,m,1);
test1(b,M,m); // M<<3
fmpz_mul(m,m,M);
test1(b,M,m); // M*(M<<3)
fmpz_clear(Mhalf);
fmpz_clear(m);
fmpz_clear(n);
fmpz_clear(M);
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("sqrtmod....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++) /* Test random integers */
{
int ans;
fmpz_t a, b, c, p;
mp_limb_t prime;
prime = n_randint(state, UWORD(1) << (FLINT_BITS - 1));
prime = n_nextprime(prime, 1);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(p);
fmpz_set_ui(p, prime);
fmpz_randm(a, state, p);
ans = fmpz_sqrtmod(b, a, p);
fmpz_mul(c, b, b);
fmpz_mod(c, c, p);
result = (ans == 0 || fmpz_equal(a, c));
if (!result)
{
flint_printf("FAIL (random):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n");
flint_printf("b = "), fmpz_print(b), flint_printf("\n");
flint_printf("c = "), fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(p);
}
for (i = 0; i < 100 * flint_test_multiplier(); i++) /* Test random squares */
{
int ans;
fmpz_t a, b, c, d, p;
mp_limb_t prime;
prime = n_randint(state, UWORD(1) << (FLINT_BITS - 1));
prime = n_nextprime(prime, 1);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(d);
fmpz_init(p);
fmpz_set_ui(p, prime);
do
fmpz_randm(b, state, p);
while (fmpz_is_zero(b));
fmpz_mul(a, b, b);
fmpz_mod(a, a, p);
/* check a special case */
if (i == 0)
{
fmpz_set_str(p, "15951355998396157", 10);
fmpz_set_str(a, "7009303413761286", 10);
}
ans = fmpz_sqrtmod(c, a, p);
fmpz_mul(d, c, c);
fmpz_mod(d, d, p);
result = (ans && fmpz_equal(a, d));
if (!result)
{
flint_printf("FAIL (squares):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n");
flint_printf("a (= b^2) = "), fmpz_print(a), flint_printf("\n");
flint_printf("b = "), fmpz_print(b), flint_printf("\n");
flint_printf("c (= sqrt(a) = "), fmpz_print(c), flint_printf("\n");
flint_printf("d (= c^2) = "), fmpz_print(d), flint_printf("\n");
flint_printf("ans = %d\n", ans);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(d);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
padic_ctx_t ctx;
fmpz_t p;
slong N;
FLINT_TEST_INIT(state);
flint_printf("inv_series... ");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 1000; i++)
{
padic_poly_t a, b, c;
slong n;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN)
+ PADIC_TEST_PREC_MIN;
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_poly_init2(a, 0, N);
padic_poly_init2(b, 0, N);
padic_poly_init2(c, 0, N);
padic_poly_randtest(a, state, n_randint(state, 100) + 1, ctx);
if (fmpz_is_zero(a->coeffs))
{
fmpz_randtest_not_zero(a->coeffs, state, 20);
fmpz_remove(a->coeffs, a->coeffs, p);
padic_poly_reduce(a, ctx);
} else
fmpz_remove(a->coeffs, a->coeffs, p);
padic_poly_set(b, a, ctx);
n = n_randint(state, 100) + 1;
padic_poly_inv_series(c, b, n, ctx);
padic_poly_inv_series(b, b, n, ctx);
result = (padic_poly_equal(b, c) && padic_poly_is_reduced(b, ctx));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = "), padic_poly_print(a, ctx), flint_printf("\n\n");
flint_printf("b = "), padic_poly_print(b, ctx), flint_printf("\n\n");
flint_printf("c = "), padic_poly_print(c, ctx), flint_printf("\n\n");
abort();
}
padic_poly_clear(a);
padic_poly_clear(b);
padic_poly_clear(c);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
/*
Check correctness:
If ord_p(a) = v then we can compute b = a^{-1} mod p^N
and we will have a b = 1 mod p^{N-|v|}. Thus, require
that N - |v| > 0.
*/
for (i = 0; i < 1000; i++)
{
padic_poly_t a, b, c;
slong n, N2;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = n_randint(state, PADIC_TEST_PREC_MAX - 1) + 1;
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_poly_init2(a, 0, N);
padic_poly_init2(b, 0, N);
{
slong i, len = n_randint(state, 10) + 1;
int alloc;
fmpz_t pow;
padic_poly_fit_length(a, len);
_padic_poly_set_length(a, len);
a->val = n_randint(state, N);
if (n_randint(state, 2))
a->val = - a->val;
alloc = _padic_ctx_pow_ui(pow, N - a->val, ctx);
for (i = 0; i < len; i++)
fmpz_randm(a->coeffs + i, state, pow);
while (fmpz_is_zero(a->coeffs))
fmpz_randm(a->coeffs, state, pow);
fmpz_remove(a->coeffs, a->coeffs, p);
_padic_poly_normalise(a);
if (alloc)
fmpz_clear(pow);
}
n = n_randint(state, 100) + 1;
N2 = N - FLINT_ABS(a->val);
padic_poly_init2(c, 0, N2);
padic_poly_inv_series(b, a, n, ctx);
padic_poly_mul(c, a, b, ctx);
padic_poly_truncate(c, n, p);
result = (padic_poly_is_one(c) && padic_poly_is_reduced(b, ctx));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = "), padic_poly_print(a, ctx), flint_printf("\n\n");
flint_printf("b = "), padic_poly_print(b, ctx), flint_printf("\n\n");
flint_printf("c = "), padic_poly_print(c, ctx), flint_printf("\n\n");
flint_printf("N = %wd\n", N);
flint_printf("N2 = %wd\n", N2);
abort();
}
padic_poly_clear(a);
padic_poly_clear(b);
padic_poly_clear(c);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("evaluate_fmpz....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
fmpz_t a, b, p;
fmpz_mod_poly_t f;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_init(a);
fmpz_init(b);
fmpz_randm(a, state, p);
fmpz_mod_poly_init(f, p);
fmpz_mod_poly_randtest(f, state, n_randint(state, 100));
fmpz_mod_poly_evaluate_fmpz(b, f, a);
fmpz_mod_poly_evaluate_fmpz(a, f, a);
result = (fmpz_equal(a, b));
if (!result)
{
printf("FAIL:\n");
fmpz_mod_poly_print(f), printf("\n\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(f);
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(p);
}
/* Check that the result agrees with Z[X] */
for (i = 0; i < 10000; i++)
{
fmpz_t a, b, c, p;
fmpz_mod_poly_t f;
fmpz_poly_t g;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_mod_poly_init(f, p);
fmpz_poly_init(g);
fmpz_randm(a, state, p);
fmpz_mod_poly_randtest(f, state, n_randint(state, 100));
fmpz_mod_poly_get_fmpz_poly(g, f);
fmpz_mod_poly_evaluate_fmpz(b, f, a);
fmpz_poly_evaluate_fmpz(c, g, a);
fmpz_mod(c, c, p);
result = (fmpz_equal(b, c));
if (!result)
{
printf("FAIL (cmp with fmpz_poly):\n");
fmpz_mod_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
fmpz_print(c), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(p);
fmpz_mod_poly_clear(f);
fmpz_poly_clear(g);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}