int
main(void)
{
int i, result;
flint_rand_t state;
printf("get_str... ");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t x;
fmpq_t y;
char *s, *t;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50) + 1;
padic_ctx_init(ctx, p, N, PADIC_TERSE);
padic_init(x, ctx);
fmpq_init(y);
padic_randtest(x, state, ctx);
_padic_get_fmpq(y, x, ctx);
s = _padic_get_str(NULL, x, ctx);
t = fmpq_get_str(NULL, 10, y);
result = strcmp(s, t) == 0;
if (!result)
{
printf("FAIL:\n\n");
printf("x = "), _padic_print(x, ctx), printf("\n");
printf("y = "), fmpq_clear(y), printf("\n");
abort();
}
free(s);
free(t);
_padic_clear(x);
fmpq_clear(y);
padic_ctx_clear(ctx);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("exp... ");
fflush(stdout);
flint_randinit(state);
/** p == 2 *******************************************************************/
/* Check aliasing: a = exp(a) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b;
int ans1, ans2;
fmpz_init(p);
fmpz_set_ui(p, 2);
N = n_randint(state, 50) + 1;
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_randtest(a, state, ctx);
ans1 = padic_exp(b, a, ctx);
ans2 = padic_exp(a, a, ctx);
result = ((ans1 == ans2) && (!ans1 || padic_equal(a, b, ctx)));
if (!result)
{
printf("FAIL (aliasing):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("ans1 = %d\n", ans1);
printf("ans2 = %d\n", ans2);
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Functional equation: exp(a + b) == exp(a) exp(b) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b, c, d, e, f, g;
int ans1, ans2, ans3;
fmpz_init(p);
fmpz_set_ui(p, 2);
N = n_randint(state, 10) + 1;
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(c, ctx);
padic_init(d, ctx);
padic_init(e, ctx);
padic_init(f, ctx);
padic_init(g, ctx);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_add(c, a, b, ctx);
ans1 = padic_exp(d, a, ctx);
ans2 = padic_exp(e, b, ctx);
padic_mul(f, d, e, ctx);
ans3 = padic_exp(g, c, ctx);
result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g, ctx)));
if (!result)
{
printf("FAIL (functional equation):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("c = a + b = "), padic_print(c, ctx), printf("\n");
printf("d = exp(a) = "), padic_print(d, ctx), printf("\n");
printf("e = exp(b) = "), padic_print(e, ctx), printf("\n");
printf("f = exp(a) exp(b) = "), padic_print(f, ctx), printf("\n");
printf("g = exp(a + b) = "), padic_print(g, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(c, ctx);
padic_clear(d, ctx);
padic_clear(e, ctx);
padic_clear(f, ctx);
padic_clear(g, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/** p > 2 ********************************************************************/
/* Check aliasing: a = exp(a) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b;
int ans1, ans2;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = n_randint(state, 50) + 1;
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_randtest(a, state, ctx);
ans1 = padic_exp(b, a, ctx);
ans2 = padic_exp(a, a, ctx);
result = ((ans1 == ans2) && (!ans1 || padic_equal(a, b, ctx)));
if (!result)
{
printf("FAIL (aliasing):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("ans1 = %d\n", ans1);
printf("ans2 = %d\n", ans2);
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Functional equation: exp(a + b) == exp(a) exp(b) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b, c, d, e, f, g;
int ans1, ans2, ans3;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = n_randint(state, 10) + 1;
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(c, ctx);
padic_init(d, ctx);
padic_init(e, ctx);
padic_init(f, ctx);
padic_init(g, ctx);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_add(c, a, b, ctx);
ans1 = padic_exp(d, a, ctx);
ans2 = padic_exp(e, b, ctx);
padic_mul(f, d, e, ctx);
ans3 = padic_exp(g, c, ctx);
result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g, ctx)));
if (!result)
{
printf("FAIL (functional equation):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("c = a + b = "), padic_print(c, ctx), printf("\n");
printf("d = exp(a) = "), padic_print(d, ctx), printf("\n");
printf("e = exp(b) = "), padic_print(e, ctx), printf("\n");
printf("f = exp(a) exp(b) = "), padic_print(f, ctx), printf("\n");
printf("g = exp(a + b) = "), padic_print(g, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(c, ctx);
padic_clear(d, ctx);
padic_clear(e, ctx);
padic_clear(f, ctx);
padic_clear(g, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("sqrt... ");
fflush(stdout);
flint_randinit(state);
/* PRIME p = 2 ***************************************************************/
/* Check aliasing: a = sqrt(a) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
int ans1, ans2;
padic_t a, d;
fmpz_init(p);
fmpz_set_ui(p, 2);
N = z_randint(state, 100);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
ans1 = padic_sqrt(d, a, ctx);
ans2 = padic_sqrt(a, a, ctx);
result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx)));
if (!result)
{
printf("FAIL (aliasing):\n\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("d = "), _padic_print(d, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Test random elements */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
int ans;
padic_t a, b, d;
fmpz_init(p);
fmpz_set_ui(p, 2);
N = z_randint(state, 100);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
ans = padic_sqrt(b, a, ctx);
padic_mul(d, b, b, ctx);
if (ans && padic_val(a) < 0)
{
padic_ctx_t ctx2;
padic_t a2, d2;
padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);
padic_init(a2, ctx2);
padic_init(d2, ctx2);
padic_set(a2, a, ctx2);
padic_set(d2, d, ctx2);
padic_reduce(a2, ctx2);
padic_reduce(d2, ctx2);
result = (padic_equal(a2, d2, ctx2));
if (!result)
{
printf("FAIL (random elements):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("a2 = "), padic_print(a2, ctx2), printf("\n");
printf("d2 = "), padic_print(d2, ctx2), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
padic_clear(a2, ctx2);
padic_clear(d2, ctx2);
padic_ctx_clear(ctx2);
}
else
{
result = (!ans || padic_equal(a, d, ctx));
if (!result)
{
printf("FAIL (random elements):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Test random squares */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
int ans;
padic_t a, b, c, d;
fmpz_init(p);
fmpz_set_ui(p, 2);
N = z_randint(state, 100);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(c, ctx);
padic_init(d, ctx);
padic_randtest(b, state, ctx);
padic_mul(a, b, b, ctx);
ans = padic_sqrt(c, a, ctx);
padic_mul(d, c, c, ctx);
if (ans && padic_val(a) < 0)
{
padic_ctx_t ctx2;
padic_t a2, d2;
padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);
padic_init(a2, ctx2);
padic_init(d2, ctx2);
padic_set(a2, a, ctx2);
padic_set(d2, d, ctx2);
padic_reduce(a2, ctx2);
padic_reduce(d2, ctx2);
result = (padic_equal(a2, d2, ctx2));
if (!result)
{
printf("FAIL (random elements):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("c = "), padic_print(c, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("a2 = "), padic_print(a2, ctx2), printf("\n");
printf("d2 = "), padic_print(d2, ctx2), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
padic_clear(a2, ctx2);
padic_clear(d2, ctx2);
padic_ctx_clear(ctx2);
}
else
{
result = (ans && padic_equal(a, d, ctx));
if (!result)
{
printf("FAIL (random squares):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("c = "), padic_print(c, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(c, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* PRIME p > 2 ***************************************************************/
/* Check aliasing: a = sqrt(a) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
int ans1, ans2;
padic_t a, d;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 100);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
ans1 = padic_sqrt(d, a, ctx);
ans2 = padic_sqrt(a, a, ctx);
result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx)));
if (!result)
{
printf("FAIL (aliasing):\n\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("d = "), _padic_print(d, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Test random elements */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
int ans;
padic_t a, b, d;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 100);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
ans = padic_sqrt(b, a, ctx);
padic_mul(d, b, b, ctx);
if (ans && padic_val(a) < 0)
{
padic_ctx_t ctx2;
padic_t a2, d2;
padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);
padic_init(a2, ctx2);
padic_init(d2, ctx2);
padic_set(a2, a, ctx2);
padic_set(d2, d, ctx2);
padic_reduce(a2, ctx2);
padic_reduce(d2, ctx2);
result = (padic_equal(a2, d2, ctx2));
if (!result)
{
printf("FAIL (random elements):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("a2 = "), padic_print(a2, ctx2), printf("\n");
printf("d2 = "), padic_print(d2, ctx2), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
padic_clear(a2, ctx2);
padic_clear(d2, ctx2);
padic_ctx_clear(ctx2);
}
else
{
result = (!ans || padic_equal(a, d, ctx));
if (!result)
{
printf("FAIL (random elements):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Test random squares */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
int ans;
padic_t a, b, c, d;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 100);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(c, ctx);
padic_init(d, ctx);
padic_randtest(b, state, ctx);
padic_mul(a, b, b, ctx);
ans = padic_sqrt(c, a, ctx);
padic_mul(d, c, c, ctx);
if (ans && padic_val(a) < 0)
{
padic_ctx_t ctx2;
padic_t a2, d2;
padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);
padic_init(a2, ctx2);
padic_init(d2, ctx2);
padic_set(a2, a, ctx2);
padic_set(d2, d, ctx2);
padic_reduce(a2, ctx2);
padic_reduce(d2, ctx2);
result = (padic_equal(a2, d2, ctx2));
if (!result)
{
printf("FAIL (random elements):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("c = "), padic_print(c, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("a2 = "), padic_print(a2, ctx2), printf("\n");
printf("d2 = "), padic_print(d2, ctx2), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
padic_clear(a2, ctx2);
padic_clear(d2, ctx2);
padic_ctx_clear(ctx2);
}
else
{
result = (ans && padic_equal(a, d, ctx));
if (!result)
{
printf("FAIL (random squares):\n\n");
printf("a = "), padic_print(a, ctx), printf("\n");
printf("b = "), padic_print(b, ctx), printf("\n");
printf("c = "), padic_print(c, ctx), printf("\n");
printf("d = "), padic_print(d, ctx), printf("\n");
printf("p = "), fmpz_print(p), printf("\n");
printf("ans = %d\n", ans);
abort();
}
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(c, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
long l, len = 20;
long runs[] = {
100000000, 1000000, 1000000, 1000000, 100000,
100000, 10000, 10000, 10000, 1000,
100, 100, 10, 1, 1,
1, 1, 1, 1, 1
};
long N[] = {
1, 2, 4, 8, 16,
32, 64, 128, 256, 512,
1024, WORD(1) << 11, WORD(1) << 12, WORD(1) << 13, WORD(1) << 14,
WORD(1) << 15, WORD(1) << 16, WORD(1) << 17, WORD(1) << 18, WORD(1) << 19
};
long T[20] = {0};
flint_printf("Benchmark for p-adic exponential (rectangular).\n");
fflush(stdout);
for (l = 0; l < FLINT_MIN(17, len); l++)
{
FLINT_TEST_INIT(state);
long n = N[l], r;
clock_t c0, c1;
long double cputime;
fmpz_t p;
padic_ctx_t ctx;
padic_t d, z;
fmpz_init_set_ui(p, 17);
padic_ctx_init(ctx, p, n, n, PADIC_VAL_UNIT);
padic_init(d);
padic_init(z);
if (n > 1)
{
fmpz_t f = {WORD(3)}, pow;
fmpz_init(pow);
fmpz_pow_ui(pow, p, n - 1);
fmpz_pow_ui(padic_unit(d), f, 3 * n);
fmpz_mod(padic_unit(d), padic_unit(d), pow);
padic_val(d) = 1;
fmpz_clear(pow);
}
c0 = clock();
for (r = runs[l]; (r); r--)
{
padic_exp_rectangular(z, d, ctx);
padic_zero(z);
}
c1 = clock();
cputime = (long double) (c1 - c0) / (long double) CLOCKS_PER_SEC;
T[l] = (slong) (cputime * (1000000000 / runs[l]));
flint_printf("%2ld, %4XYXYXYXY, %9ld, %wd\n",
l, cputime, runs[l], T[l]);
padic_clear(d);
padic_clear(z);
fmpz_clear(p);
padic_ctx_clear(ctx);
flint_randclear(state);
}
flint_printf("Output as a list:\n");
for (l = 0; l < len; l++)
flint_printf("%wd, ", T[l]);
flint_printf("\n");
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("mul... ");
fflush(stdout);
flint_randinit(state);
/* Check aliasing: a = a * b (mod p^N) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b, d;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_mul(d, a, b, ctx);
padic_mul(a, a, b, ctx);
result = (padic_equal(a, d, ctx));
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("b = "), _padic_print(b, ctx), printf("\n");
printf("d = "), _padic_print(d, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Check aliasing: b = a * b (mod p^N) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b, d;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_mul(d, a, b, ctx);
padic_mul(b, a, b, ctx);
result = (padic_equal(b, d, ctx));
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("b = "), _padic_print(b, ctx), printf("\n");
printf("d = "), _padic_print(d, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Check aliasing: a = a * a (mod p^N) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, d;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
padic_mul(d, a, a, ctx);
padic_mul(a, a, a, ctx);
result = (padic_equal(a, d, ctx));
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("d = "), _padic_print(d, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Check that a * b == b * a (mod p^N) */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b, c, d;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(c, ctx);
padic_init(d, ctx);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_mul(c, a, b, ctx);
padic_mul(d, b, a, ctx);
result = (padic_equal(c, d, ctx));
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("b = "), _padic_print(b, ctx), printf("\n");
printf("c = "), _padic_print(c, ctx), printf("\n");
printf("d = "), _padic_print(d, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(c, ctx);
padic_clear(d, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Check that (a * b) * c == a * (b * c), correct only mod p^{N-v} */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b, c, d, e;
long v;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_init(c, ctx);
padic_init(d, ctx);
padic_init(e, ctx);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_randtest(c, state, ctx);
v = FLINT_MIN(padic_val(a), padic_val(b));
v = FLINT_MIN(v, padic_val(c));
v = FLINT_MIN(v, 0);
if ((v >= 0) || (-v < N)) /* Otherwise, no precision left */
{
padic_ctx_t ctx2;
padic_ctx_init(ctx2, p, (v >= 0) ? N : N + v, PADIC_SERIES);
padic_mul(d, a, b, ctx);
padic_mul(d, d, c, ctx);
padic_mul(e, b, c, ctx);
padic_mul(e, a, e, ctx);
padic_reduce(d, ctx2);
padic_reduce(e, ctx2);
result = (padic_equal(d, e, ctx2));
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("b = "), _padic_print(b, ctx), printf("\n");
printf("c = "), _padic_print(c, ctx), printf("\n");
printf("d = "), _padic_print(d, ctx2), printf("\n");
printf("e = "), _padic_print(e, ctx2), printf("\n");
abort();
}
padic_ctx_clear(ctx2);
}
padic_clear(a, ctx);
padic_clear(b, ctx);
padic_clear(c, ctx);
padic_clear(d, ctx);
padic_clear(e, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Check that a * 1 == a */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50);
padic_ctx_init(ctx, p, N, PADIC_SERIES);
padic_init(a, ctx);
padic_init(b, ctx);
padic_randtest(a, state, ctx);
_padic_one(b);
padic_mul(b, a, b, ctx);
result = (padic_equal(a, b, ctx));
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), _padic_print(a, ctx), printf("\n");
printf("b = "), _padic_print(b, ctx), printf("\n");
abort();
}
padic_clear(a, ctx);
padic_clear(b, ctx);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
long l, len = 20;
long runs[] = {
1000000, 1000000, 1000000, 1000000, 100000,
100000, 100000, 100000, 10000, 10000,
10000, 1000, 1000, 100, 100,
10, 10, 1, 1, 1
};
long N[] = {
1, 2, 4, 8, 16,
32, 64, 128, 256, 512,
1024, WORD(1) << 11, WORD(1) << 12, WORD(1) << 13, WORD(1) << 14,
WORD(1) << 15, WORD(1) << 16, WORD(1) << 17, WORD(1) << 18, WORD(1) << 19
};
long T[20] = {0};
flint_printf("Benchmark for p-adic Teichmuller.\n");
fflush(stdout);
for (l = 0; l < len; l++)
{
FLINT_TEST_INIT(state);
long n = N[l], r;
clock_t c0, c1;
long double cputime;
fmpz_t p;
padic_ctx_t ctx;
padic_t c, z;
fmpz_init_set_ui(p, 17);
padic_ctx_init(ctx, p, n, n, PADIC_VAL_UNIT);
padic_init(c);
padic_init(z);
fmpz_set_ui(padic_unit(c), 3);
c0 = clock();
for (r = runs[l]; (r); r--)
{
padic_teichmuller(z, c, ctx);
padic_zero(z);
}
c1 = clock();
cputime = (long double) (c1 - c0) / (long double) CLOCKS_PER_SEC;
T[l] = (slong) (cputime * (1000000000 / runs[l]));
flint_printf("%2ld, %4XYXYXYXY, %7ld, %wd\n",
l, cputime, runs[l], T[l]);
padic_clear(c);
padic_clear(z);
fmpz_clear(p);
padic_ctx_clear(ctx);
flint_randclear(state);
}
flint_printf("Output as a list:\n");
for (l = 0; l < len; l++)
flint_printf("%wd, ", T[l]);
flint_printf("\n");
}
