static void entry(fmpz_t rop_u, long *rop_v,
const long *u, const long *v, const fmpz *a, const fmpz *dinv,
const fmpz **mu, long M, const long **C, const long *lenC,
long n, long d, long p, long N, long N2)
{
const long ku = diagfrob_k(u, n, d);
const long kv = diagfrob_k(v, n, d);
fmpz_t f, g, P;
fmpz_init(f);
fmpz_init(g);
fmpz_init_set_ui(P, p);
/*
Compute $g := (u'-1)! \alpha_{u+1,v+1}$ to precision $N2$.
*/
fmpz_fac_ui(f, ku - 1);
alpha(g, u, v, a, dinv, mu, M, C, lenC, n, d, p, N2);
fmpz_mul(g, f, g);
/*
Compute $f := (-1)^{u'+v'} (v'-1)!$ exactly.
*/
fmpz_fac_ui(f, kv - 1);
if ((ku + kv) % 2 != 0)
{
fmpz_neg(f, f);
}
/*
Set rop to the product of $f$ and $g^{-1} mod $p^N$.
*/
*rop_v = fmpz_remove(f, f, P) + n - fmpz_remove(g, g, P);
if (*rop_v >= N)
{
fmpz_zero(rop_u);
*rop_v = 0;
}
else
{
_padic_inv(g, g, P, N - *rop_v);
fmpz_mul(rop_u, f, g);
fmpz_pow_ui(f, P, N - *rop_v);
fmpz_mod(rop_u, rop_u, f);
}
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(P);
}
static void
_padic_log_bsplit(fmpz_t z, const fmpz_t y, long v, const fmpz_t p, long N)
{
fmpz_t P, B, T;
long n;
if (fmpz_fits_si(p))
n = _padic_log_bound(v, N, fmpz_get_si(p));
else
n = (N - 1) / v;
n = FLINT_MAX(n, 2);
fmpz_init(P);
fmpz_init(B);
fmpz_init(T);
_padic_log_bsplit_series(P, B, T, y, 1, n);
n = fmpz_remove(B, B, p);
fmpz_pow_ui(P, p, n);
fmpz_divexact(T, T, P);
_padic_inv(B, B, p, N);
fmpz_mul(z, T, B);
fmpz_clear(P);
fmpz_clear(B);
fmpz_clear(T);
}
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;
}
}
static void
_qadic_exp_bsplit(fmpz *y, const fmpz *x, slong v, slong len,
const fmpz *a, const slong *j, slong lena,
const fmpz_t p, slong N)
{
const slong d = j[lena - 1];
const slong n = _padic_exp_bound(v, N, p);
if (n == 1)
{
fmpz_one(y + 0);
_fmpz_vec_zero(y + 1, d - 1);
}
else
{
fmpz *P, *T;
fmpz_t Q, R;
slong f;
P = _fmpz_vec_init(2*d - 1);
T = _fmpz_vec_init(2*d - 1);
fmpz_init(Q);
fmpz_init(R);
_qadic_exp_bsplit_series(P, Q, T, x, len, 1, n, a, j, lena);
fmpz_add(T + 0, T + 0, Q); /* (T,Q) := (T,Q) + 1 */
/* Note exp(x) is a unit so val(T) == val(Q). */
f = fmpz_remove(Q, Q, p);
fmpz_pow_ui(R, p, f);
_fmpz_vec_scalar_divexact_fmpz(T, T, d, R);
_padic_inv(Q, Q, p, N);
_fmpz_vec_scalar_mul_fmpz(y, T, d, Q);
_fmpz_vec_clear(P, 2*d - 1);
_fmpz_vec_clear(T, 2*d - 1);
fmpz_clear(Q);
fmpz_clear(R);
}
}
int _padic_poly_fprint(FILE *file, const fmpz *poly, slong val, slong len,
const padic_ctx_t ctx)
{
slong i, v;
fmpz_t u;
if (len == 0)
{
flint_fprintf(file, "0");
return 1;
}
fmpz_init(u);
flint_fprintf(file, "%wd ", len);
for (i = 0; i < len; i++)
{
flint_fprintf(file, " ");
if (fmpz_is_zero(poly + i))
{
flint_fprintf(file, "0");
}
else
{
v = val + fmpz_remove(u, poly + i, ctx->p);
_padic_fprint(file, u, v, ctx);
}
}
fmpz_clear(u);
return 1;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("remove....");
fflush(stdout);
/* Compare with MPIR, random input */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c;
mpz_t d, e, f, g;
slong x, y;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
x = fmpz_remove(c, a, b);
y = mpz_remove(f, d, e);
fmpz_get_mpz(g, c);
result = ((x == y) && (mpz_cmp(f, g) == 0));
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Compare with MPIR, random input but ensure that factors exist */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c, pow;
mpz_t d, e, f, g;
slong x, y;
ulong n;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(pow);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
n = n_randint(state, 10);
fmpz_pow_ui(pow, b, n);
fmpz_mul(a, a, pow);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
x = fmpz_remove(c, a, b);
y = mpz_remove(f, d, e);
fmpz_get_mpz(g, c);
result = ((x == y) && (x >= n) && (mpz_cmp(f, g) == 0));
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(pow);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Check aliasing of a and b */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_t a, c;
slong x;
fmpz_init(a);
fmpz_init(c);
do {
fmpz_randtest_not_zero(a, state, 200);
fmpz_abs(a, a);
} while (fmpz_is_one(a));
x = fmpz_remove(c, a, a);
result = ((x == 1) && (fmpz_cmp_ui(c, 1) == 0));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n");
fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c;
slong x, y;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
x = fmpz_remove(c, a, b);
y = fmpz_remove(a, a, b);
result = ((x == y) && fmpz_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n");
fmpz_print(b), flint_printf("\n");
fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
}
/* Check aliasing of b and c */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c;
slong x, y;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_randtest_not_zero(a, state, 200);
do {
fmpz_randtest_not_zero(b, state, 200);
fmpz_abs(b, b);
} while (fmpz_is_one(b));
x = fmpz_remove(c, a, b);
y = fmpz_remove(b, a, b);
result = ((x == y) && fmpz_equal(b, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n");
fmpz_print(b), flint_printf("\n");
fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
}
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;
}
