int padic_log_balanced(padic_t rop, const padic_t op, const padic_ctx_t ctx)
{
if (padic_val(op) < 0)
{
return 0;
}
else
{
fmpz_t x;
int ans;
fmpz_init(x);
padic_get_fmpz(x, op, ctx);
fmpz_sub_ui(x, x, 1);
if (fmpz_is_zero(x))
{
padic_zero(rop);
ans = 1;
}
else
{
fmpz_t t;
long v;
fmpz_init(t);
v = fmpz_remove(t, x, ctx->p);
fmpz_clear(t);
if (v >= 2 || (*(ctx->p) != 2L && v >= 1))
{
if (v >= ctx->N)
{
padic_zero(rop);
}
else
{
_padic_log_balanced(padic_unit(rop), x, v, ctx->p, ctx->N);
padic_val(rop) = 0;
padic_reduce(rop, ctx);
}
ans = 1;
}
else
{
ans = 0;
}
}
fmpz_clear(x);
return ans;
}
}
void qadic_trace(padic_t rop, const qadic_t op, const qadic_ctx_t ctx)
{
const slong N = padic_prec(rop);
if (qadic_is_zero(op) || op->val >= N)
{
padic_zero(rop);
}
else
{
fmpz_t pN;
int alloc;
alloc = _padic_ctx_pow_ui(pN, N - op->val, &ctx->pctx);
_qadic_trace(padic_unit(rop), op->coeffs, op->length,
ctx->a, ctx->j, ctx->len, pN);
padic_val(rop) = op->val;
_padic_canonicalise(rop, &ctx->pctx);
if (alloc)
fmpz_clear(pN);
}
}
void padic_teichmuller(padic_t rop, const padic_t op, const padic_ctx_t ctx)
{
if (padic_val(op) < 0)
{
flint_printf("Exception (padic_teichmuller). op is not a p-adic integer.\n");
abort();
}
if (padic_is_zero(op) || padic_val(op) > 0 || padic_prec(rop) <= 0)
{
padic_zero(rop);
}
else
{
_padic_teichmuller(padic_unit(rop), padic_unit(op), ctx->p, padic_prec(rop));
padic_val(rop) = 0;
}
}
void _padic_reduce(padic_t rop, const padic_ctx_t ctx)
{
if (!fmpz_is_zero(padic_unit(rop)))
{
if (padic_val(rop) < ctx->N)
{
int alloc;
fmpz_t pow;
alloc = _padic_ctx_pow_ui(pow, ctx->N - padic_val(rop), ctx);
fmpz_mod(padic_unit(rop), padic_unit(rop), pow);
if (alloc)
fmpz_clear(pow);
}
else
{
fmpz_zero(padic_unit(rop));
padic_val(rop) = 0;
}
}
}
void qadic_norm_resultant(padic_t rop, const qadic_t op, const qadic_ctx_t ctx)
{
const slong N = padic_prec(rop);
const slong d = qadic_ctx_degree(ctx);
/* N(p^v u) = p^{dv} N(u) */
if (qadic_is_zero(op) || d * op->val >= N)
{
padic_zero(rop);
}
else
{
_qadic_norm_resultant(padic_unit(rop), op->coeffs, op->length,
ctx->a, ctx->j, ctx->len, (&ctx->pctx)->p,
N - d * op->val);
padic_val(rop) = d * op->val;
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("log_rectangular... ");
fflush(stdout);
flint_randinit(state);
/** p == 2 *******************************************************************/
/** p > 2 ********************************************************************/
/* Check aliasing: a = log(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 = n_randint(state, 50) + 1;
padic_ctx_init(ctx, p, N, PADIC_SERIES);
_padic_init(a);
_padic_init(b);
padic_randtest(a, state, ctx);
if (!_padic_is_zero(a) && (padic_val(a) < 1 || (*p == 2L && padic_val(a) < 2)))
{
padic_val(a) = (*p == 2L) + 1;
padic_reduce(a, ctx);
}
_padic_one(b);
_padic_add(a, a, b, ctx);
padic_log_rectangular(b, a, ctx);
padic_log_rectangular(a, a, ctx);
result = (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");
abort();
}
_padic_clear(a);
_padic_clear(b);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Check: log(a) + log(b) == log(a * 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;
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);
_padic_init(b);
_padic_init(c);
_padic_init(d);
_padic_init(e);
_padic_init(f);
_padic_init(g);
padic_randtest(a, state, ctx);
if (!_padic_is_zero(a) && (padic_val(a) < 1 || (*p == 2L && padic_val(a) < 2)))
{
padic_val(a) = (*p == 2L) + 1;
padic_reduce(a, ctx);
}
_padic_one(c);
_padic_add(a, a, c, ctx);
padic_randtest(b, state, ctx);
if (!_padic_is_zero(b) && (padic_val(b) < 1 || (*p == 2L && padic_val(b) < 2)))
{
padic_val(b) = (*p == 2L) + 1;
padic_reduce(b, ctx);
}
_padic_one(c);
_padic_add(b, b, c, ctx);
padic_mul(c, a, b, ctx);
padic_log_rectangular(d, a, ctx);
padic_log_rectangular(e, b, ctx);
padic_add(f, d, e, ctx);
padic_log_rectangular(g, c, ctx);
result = (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 = log(a) = "), padic_print(d, ctx), printf("\n");
printf("e = log(b) = "), padic_print(e, ctx), printf("\n");
printf("f = log(a) + log(b) = "), padic_print(f, ctx), printf("\n");
printf("g = log(a * b) = "), padic_print(g, ctx), printf("\n");
abort();
}
_padic_clear(a);
_padic_clear(b);
_padic_clear(c);
_padic_clear(d);
_padic_clear(e);
_padic_clear(f);
_padic_clear(g);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
/* Check: log(exp(x)) == x */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t a, b, c;
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);
_padic_init(b);
_padic_init(c);
padic_randtest(a, state, ctx);
if (!_padic_is_zero(a) && (padic_val(a) < 1 || (*p == 2L && padic_val(a) < 2)))
{
padic_val(a) = (*p == 2L) + 1;
padic_reduce(a, ctx);
}
padic_exp(b, a, ctx);
padic_log_rectangular(c, b, ctx);
result = (padic_equal(a, c, ctx));
if (!result)
{
printf("FAIL (log(exp(x)) == x):\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");
abort();
}
_padic_clear(a);
_padic_clear(b);
_padic_clear(c);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
char * _padic_get_str(char * str, const padic_t op, const padic_ctx_t ctx)
{
const fmpz * u = padic_unit(op);
const long v = padic_val(op);
if (fmpz_is_zero(u))
{
if (!str)
{
str = flint_malloc(2);
}
str[0] = '0';
str[1] = '\0';
return str;
}
if (ctx->mode == PADIC_TERSE)
{
if (v == 0)
{
str = fmpz_get_str(str, 10, u);
}
else if (v > 0)
{
fmpz_t t;
fmpz_init(t);
fmpz_pow_ui(t, ctx->p, v);
fmpz_mul(t, t, u);
str = fmpz_get_str(str, 10, t);
fmpz_clear(t);
}
else /* v < 0 */
{
fmpz_t t;
fmpz_init(t);
fmpz_pow_ui(t, ctx->p, -v);
str = _fmpq_get_str(str, 10, u, t);
fmpz_clear(t);
}
}
else if (ctx->mode == PADIC_SERIES)
{
char *s;
fmpz_t x;
fmpz_t d;
long j, N;
if (fmpz_sgn(u) < 0)
{
printf("ERROR (_padic_get_str). u < 0 in SERIES mode.\n");
abort();
}
N = fmpz_clog(u, ctx->p) + v;
if (!str)
{
long b = (N - v) * (2 * fmpz_sizeinbase(ctx->p, 10)
+ z_sizeinbase(FLINT_MAX(FLINT_ABS(v), FLINT_ABS(N)), 10)
+ 5) + 1;
str = flint_malloc(b);
if (!str)
{
printf("ERROR (_padic_get_str). Memory allocation failed.\n");
abort();
}
}
s = str;
fmpz_init(d);
fmpz_init(x);
fmpz_set(x, u);
/* Unroll first step */
j = 0;
{
fmpz_mod(d, x, ctx->p); /* d = u mod p^{j+1} */
fmpz_sub(x, x, d); /* x = x - d */
fmpz_divexact(x, x, ctx->p); /* x = x / p */
if (!fmpz_is_zero(d))
{
if (j + v != 0)
{
fmpz_get_str(s, 10, d);
while (*++s != '\0') ;
*s++ = '*';
fmpz_get_str(s, 10, ctx->p);
while (*++s != '\0') ;
*s++ = '^';
sprintf(s, "%ld", j + v);
while (*++s != '\0') ;
}
else
{
fmpz_get_str(s, 10, d);
while (*++s != '\0') ;
}
}
j++;
}
for ( ; !fmpz_is_zero(x); j++)
{
fmpz_mod(d, x, ctx->p); /* d = u mod p^{j+1} */
fmpz_sub(x, x, d); /* x = x - d */
fmpz_divexact(x, x, ctx->p); /* x = x / p */
if (!fmpz_is_zero(d))
{
if (j + v != 0)
{
*s++ = ' ';
*s++ = '+';
*s++ = ' ';
fmpz_get_str(s, 10, d);
while (*++s != '\0') ;
*s++ = '*';
fmpz_get_str(s, 10, ctx->p);
while (*++s != '\0') ;
*s++ = '^';
sprintf(s, "%ld", j + v);
while (*++s != '\0') ;
}
else
{
*s++ = ' ';
*s++ = '+';
*s++ = ' ';
fmpz_get_str(s, 10, d);
while (*++s != '\0') ;
}
}
}
fmpz_clear(x);
fmpz_clear(d);
}
else /* ctx->mode == PADIC_VAL_UNIT */
{
if (!str)
{
long b = fmpz_sizeinbase(u, 10) + fmpz_sizeinbase(ctx->p, 10)
+ z_sizeinbase(v, 10) + 4;
str = flint_malloc(b);
if (!str)
{
printf("ERROR (_padic_get_str). Memory allocation failed.\n");
abort();
}
}
if (v == 0)
{
str = fmpz_get_str(str, 10, u);
}
else if (v == 1)
{
char *s = str;
fmpz_get_str(s, 10, u);
while (*++s != '\0') ;
*s++ = '*';
fmpz_get_str(s, 10, ctx->p);
}
else
{
char *s = str;
fmpz_get_str(s, 10, u);
while (*++s != '\0') ;
*s++ = '*';
fmpz_get_str(s, 10, ctx->p);
while (*++s != '\0') ;
*s++ = '^';
sprintf(s, "%ld", v);
}
}
return str;
}
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;
}
