static void precompute_dinv_p(fmpz *list, long M, long d, long p, long N)
{
fmpz_one(list + 0);
if (M >= p)
{
fmpz_t P, PN;
long r;
fmpz_init_set_ui(P, p);
fmpz_init(PN);
fmpz_pow_ui(PN, P, N);
fmpz_set_ui(list + 1, d);
_padic_inv(list + 1, list + 1, P, N);
for (r = 2; r <= M / p; r++)
{
fmpz_mul(list + r, list + (r - 1), list + 1);
fmpz_mod(list + r, list + r, PN);
}
fmpz_clear(P);
fmpz_clear(PN);
}
}
void arb_fib_ui(arb_t f, ulong n, slong prec)
{
fmpz_t t;
fmpz_init_set_ui(t, n);
arb_fib_fmpz(f, t, prec);
fmpz_clear(t);
}
void
test1_ui(mp_limb_t log2,const fmpz_t b,mp_limb_t mm)
{
fmpz_t m; fmpz_init_set_ui(m,mm);
test1(log2,b,m);
fmpz_clear(m);
}
/* TODO: Move into separate function / optimize */
void fq_nmod_pow_ui(fq_nmod_t rop, const fq_nmod_t op, const ulong e, const fq_nmod_ctx_t ctx)
{
fmpz_t exp;
fmpz_init_set_ui(exp, e);
fq_nmod_pow(rop, op, exp, ctx);
fmpz_clear(exp);
}
void
acb_pow_ui(acb_t y, const acb_t b, ulong e, long prec)
{
fmpz_t f;
fmpz_init_set_ui(f, e);
acb_pow_fmpz(y, b, f, prec);
fmpz_clear(f);
}
void
fmpr_pow_sloppy_ui(fmpr_t y, const fmpr_t b, ulong e, long prec, fmpr_rnd_t rnd)
{
fmpz_t f;
fmpz_init_set_ui(f, e);
fmpr_pow_sloppy_fmpz(y, b, f, prec, rnd);
fmpz_clear(f);
}
int
fmpz_invmod_ui(fmpz_t f, const fmpz_t g, const uint32_t mod)
{
fmpz_t modulus;
fmpz_init_set_ui(modulus, mod);
return fmpz_invmod(f, g, modulus);
}
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 dsum_p(
fmpz_t rop,
const fmpz *dinv, const fmpz *mu, long M, const long *C, long lenC,
const fmpz_t a, long ui, long vi, long n, long d, long p, long N)
{
long m, r, idx;
fmpz_t apm1, apow, f, g, P, PN;
fmpz_init(apm1);
fmpz_init(apow);
fmpz_init(f);
fmpz_init(g);
fmpz_init_set_ui(P, p);
fmpz_init(PN);
fmpz_pow_ui(PN, P, N);
fmpz_zero(rop);
r = 0;
m = (p * (ui + 1) - (vi + 1)) / d;
if (m <= M) /* Step {r = 0} */
{
idx = _bsearch(C, 0, lenC, m % p);
fmpz_powm_ui(apm1, a, p - 1, PN);
fmpz_one(apow);
fmpz_one(f);
fmpz_mod(rop, mu + idx + lenC * (m / p), PN);
}
for (r = 1, m += p; m <= M; r++, m += p)
{
idx = _bsearch(C, 0, lenC, m % p);
fmpz_mul(apow, apow, apm1);
fmpz_mod(apow, apow, PN);
fmpz_mul_ui(f, f, ui + 1 + (r - 1) * d);
fmpz_mod(f, f, PN);
fmpz_mul(g, f, dinv + r);
fmpz_mul(g, g, apow);
fmpz_mul(g, g, mu + idx + lenC * (m / p));
fmpz_mod(g, g, PN);
fmpz_add(rop, rop, g);
}
fmpz_mod(rop, rop, PN);
fmpz_clear(apm1);
fmpz_clear(apow);
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(P);
fmpz_clear(PN);
}
void
arb_div_2expm1_ui(arb_t y, const arb_t x, ulong n, long prec)
{
if (n < FLINT_BITS)
{
arb_div_ui(y, x, (1UL << n) - 1, prec);
}
else if (n < 1024 + prec / 32 || n > LONG_MAX / 4)
{
arb_t t;
fmpz_t e;
arb_init(t);
fmpz_init_set_ui(e, n);
arb_one(t);
arb_mul_2exp_fmpz(t, t, e);
arb_sub_ui(t, t, 1, prec);
arb_div(y, x, t, prec);
arb_clear(t);
fmpz_clear(e);
}
else
{
arb_t s, t;
long i, b;
arb_init(s);
arb_init(t);
/* x / (2^n - 1) = sum_{k>=1} x * 2^(-k*n)*/
arb_mul_2exp_si(s, x, -n);
arb_set(t, s);
b = 1;
for (i = 2; i <= prec / n + 1; i++)
{
arb_mul_2exp_si(t, t, -n);
arb_add(s, s, t, prec);
b = i;
}
/* error bound: sum_{k>b} x * 2^(-k*n) <= x * 2^(-b*n - (n-1)) */
arb_mul_2exp_si(t, x, -b*n - (n-1));
arb_abs(t, t);
arb_add_error(s, t);
arb_set(y, s);
arb_clear(s);
arb_clear(t);
}
}
int
main()
{
flint_randinit(st);
fmpz_init_set_ui( two__64, UWORD(1)<<32 );
fmpz_mul( two__64, two__64, two__64 );
int i;
test_0( WORD(0) );
for(i=100;i--;)
test_0( R() );
fmpz_clear(two__64);
flint_printf("Test passed\n");
return 0;
}
int main(int argc, char **argv)
{
const mmap_vtable *const mmap = &clt_vtable;
/* const mmap_vtable *const mmap = &gghlite_vtable; */
if (argc == 1)
return 0;
ulong lambda = atoi(argv[1]);
ulong kappa = atoi(argv[2]);
ulong nzs = kappa;
aes_randstate_t rng;
aes_randinit(rng);
mmap_sk *sk = malloc(mmap->sk->size);
mmap->sk->init(sk, lambda, kappa, nzs, NULL, 0, 1, rng, false);
const mmap_pp *const pp = mmap->sk->pp(sk);
mmap_enc x;
mmap->enc->init(&x, pp);
for (int i = 0; i < kappa; i++) {
fmpz_t pt [1];
fmpz_init_set_ui(pt[0], 10);
int ix [nzs];
for (int j = 0; j < nzs; j++) {
ix[j] = i == j;
}
if (i == 0) {
mmap->enc->encode(&x, sk, 1, pt, ix);
} else {
mmap_enc y;
mmap->enc->init(&y, pp);
mmap->enc->encode(&y, sk, 1, pt, ix);
mmap->enc->mul(&x, pp, &x, &y);
}
}
FILE *fp = fopen("encoding.bin", "w+");
if (fp == NULL) {
fprintf(stderr, "Couldn't open encoding.bin!\n");
exit(1);
}
mmap->enc->fwrite(&x, fp);
return 0;
}
void
mag_root(mag_t y, const mag_t x, ulong n)
{
if (n == 0)
{
mag_inf(y);
}
else if (n == 1 || mag_is_special(x))
{
mag_set(y, x);
}
else if (n == 2)
{
mag_sqrt(y, x);
}
else if (n == 4)
{
mag_sqrt(y, x);
mag_sqrt(y, y);
}
else
{
fmpz_t e, f;
fmpz_init_set_ui(e, MAG_BITS);
fmpz_init(f);
/* We evaluate exp(log(1+2^(kn)x)/n) 2^-k where k is chosen
so that 2^(kn) x ~= 2^30. TODO: this rewriting is probably
unnecessary with the new exp/log functions. */
fmpz_sub(e, e, MAG_EXPREF(x));
fmpz_cdiv_q_ui(e, e, n);
fmpz_mul_ui(f, e, n);
mag_mul_2exp_fmpz(y, x, f);
mag_log1p(y, y);
mag_div_ui(y, y, n);
mag_exp(y, y);
fmpz_neg(e, e);
mag_mul_2exp_fmpz(y, y, e);
fmpz_clear(e);
fmpz_clear(f);
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("init_set_ui....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
ulong x = n_randtest(state);
fmpz_init(a);
fmpz_set_ui(a, x);
fmpz_init_set_ui(b, x);
result = fmpz_equal(a, b);
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), fmpz_print(a), printf("\n");
printf("b = "), fmpz_print(b), printf("\n");
printf("x = %lu\n", x);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
static void alpha(fmpz_t rop, 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)
{
const long ku = diagfrob_k(u, n, d);
long i;
fmpz_t f, g, P, PN;
fmpz_init(f);
fmpz_init(g);
fmpz_init_set_ui(P, p);
fmpz_init(PN);
fmpz_pow_ui(PN, P, N);
fmpz_pow_ui(rop, P, ku);
fmpz_mod(rop, rop, PN);
for (i = 0; i <= n; i++)
{
long e = (p * (u[i] + 1) - (v[i] + 1)) / d;
fmpz_powm_ui(f, a + i, e, PN);
dsum(g, dinv, mu[i], M, C[i], lenC[i], a + i, u[i], v[i], n, d, p, N);
fmpz_mul(rop, rop, f);
fmpz_mul(rop, rop, g);
fmpz_mod(rop, rop, PN);
}
if (ku % 2 != 0 && !fmpz_is_zero(rop))
{
fmpz_sub(rop, PN, rop);
}
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(P);
fmpz_clear(PN);
}
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);
}
static void precompute_nu(fmpz *nu, long *v, long M,
const long *C, long lenC, long p, long N)
{
const long R = M / p;
const long N2 = N + (M / (p - 1));
fmpz_t P, PN2, t;
padic_inv_t S;
double pinv;
long i, j;
fmpz_init_set_ui(P, p);
fmpz_init(PN2);
fmpz_pow_ui(PN2, P, N2);
fmpz_init(t);
/*
Step 1. Compute $i! mod p^{N_2}$ where $N_2 \geq N + \max \ord_p (i!)$
Step 2. Invert the unit part of $i!$ modulo $p^N$
*/
fmpz_one(nu + 0);
for (i = 1; i <= R; i++)
{
fmpz_mul_ui(nu + i, nu + (i - 1), i);
fmpz_mod(nu + i, nu + i, PN2);
}
/* Let j denote the greatest index s.t. nu[j] has been computed */
for (j = R, i = R + 1; i <= M; i++)
{
if (_bsearch(C, 0, lenC, i % p) != -1)
{
fmpz_mod_rfac_uiui(t, j + 1, i - j, PN2);
fmpz_mul(nu + i, nu + j, t);
fmpz_mod(nu + i, nu + i, PN2);
j = i;
}
}
_padic_inv_precompute(S, P, N);
pinv = n_precompute_inverse(p);
v[0] = 0;
for (i = 1; i <= R; i++)
{
v[i] = - _fmpz_remove(nu + i, P, pinv);
_padic_inv_precomp(nu + i, nu + i, S);
}
for (i = R + 1; i <= M; i++)
{
if (_bsearch(C, 0, lenC, i % p) != -1)
{
v[i] = - _fmpz_remove(nu + i, P, pinv);
_padic_inv_precomp(nu + i, nu + i, S);
}
}
fmpz_clear(P);
fmpz_clear(PN2);
fmpz_clear(t);
_padic_inv_clear(S);
}
void precompute_muex(fmpz **mu, long M,
const long **C, const long *lenC,
const fmpz *a, long n, long p, long N)
{
const long ve = (p == 2) ? M / 4 + 1 : M / (p * (p - 1)) + 1;
fmpz_t P, pNe, pe;
fmpz_t apow, f, g, h;
fmpz *nu;
long *v;
long i, j;
fmpz_init_set_ui(P, p);
fmpz_init(pNe);
fmpz_init(pe);
fmpz_pow_ui(pNe, P, N + ve);
fmpz_pow_ui(pe, P, ve);
fmpz_init(apow);
fmpz_init(f);
fmpz_init(g);
fmpz_init(h);
/* Precompute $(l!)^{-1}$ */
nu = _fmpz_vec_init(M + 1);
v = malloc((M + 1) * sizeof(long));
{
long *D, lenD = 0, k = 0;
for (i = 0; i <= n; i++)
lenD += lenC[i];
D = malloc(lenD * sizeof(long));
for (i = 0; i <= n; i++)
for (j = 0; j < lenC[i]; j++)
D[k++] = C[i][j];
_remove_duplicates(D, &lenD);
_sort(D, lenD);
precompute_nu(nu, v, M, D, lenD, p, N + ve);
free(D);
}
for (i = 0; i <= n; i++)
{
long m = -1, quo, idx, w;
fmpz *z;
/* Set apow = a[i]^{-(p-1)} mod p^N */
fmpz_invmod(apow, a + i, pNe);
fmpz_powm_ui(apow, apow, p - 1, pNe);
/*
Run over all relevant m in [0, M].
Note that lenC[i] > 0 for all i.
*/
for (quo = 0; m <= M; quo++)
{
for (idx = 0; idx < lenC[i]; idx++)
{
m = quo * p + C[i][idx];
if (m > M)
break;
/*
Note that $\mu_m$ is equal to
$\sum_{k=0}^{\floor{m/p}} p^{\floor{m/p}-k}\nu_{m-pk}\nu_k$
where $\nu_i$ denotes the number with unit part nu[i]
and valuation v[i].
*/
w = (p == 2) ? (3 * m) / 4 - (m == 3 || m == 7) : m / p;
z = mu[i] + lenC[i] * quo + idx;
fmpz_zero(z);
fmpz_one(h);
for (j = 0; j <= m / p; j++)
{
fmpz_pow_ui(f, P, ve + w - j + v[m - p*j] + v[j]);
fmpz_mul(g, nu + (m - p*j), nu + j);
fmpz_mul(f, f, g);
fmpz_mul(f, f, h);
fmpz_add(z, z, f);
fmpz_mod(z, z, pNe);
/* Set h = a[i]^{- (j+1)(p-1)} mod p^{N+e} */
fmpz_mul(h, h, apow);
fmpz_mod(h, h, pNe);
}
fmpz_divexact(z, z, pe);
}
}
}
fmpz_clear(P);
fmpz_clear(pNe);
fmpz_clear(pe);
fmpz_clear(apow);
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(h);
_fmpz_vec_clear(nu, M + 1);
free(v);
}
void frob(const mpoly_t P, const ctx_t ctxFracQt,
const qadic_t t1, const qadic_ctx_t Qq,
prec_t *prec, const prec_t *prec_in,
int verbose)
{
const padic_ctx_struct *Qp = &Qq->pctx;
const fmpz *p = Qp->p;
const long a = qadic_ctx_degree(Qq);
const long n = P->n - 1;
const long d = mpoly_degree(P, -1, ctxFracQt);
const long b = gmc_basis_size(n, d);
long i, j, k;
/* Diagonal fibre */
padic_mat_t F0;
/* Gauss--Manin Connection */
mat_t M;
mon_t *bR, *bC;
fmpz_poly_t r;
/* Local solution */
fmpz_poly_mat_t C, Cinv;
long vC, vCinv;
/* Frobenius */
fmpz_poly_mat_t F;
long vF;
fmpz_poly_mat_t F1;
long vF1;
fmpz_poly_t cp;
clock_t c0, c1;
double c;
if (verbose)
{
printf("Input:\n");
printf(" P = "), mpoly_print(P, ctxFracQt), printf("\n");
printf(" p = "), fmpz_print(p), printf("\n");
printf(" t1 = "), qadic_print_pretty(t1, Qq), printf("\n");
printf("\n");
fflush(stdout);
}
/* Step 1 {M, r} *********************************************************/
c0 = clock();
mat_init(M, b, b, ctxFracQt);
fmpz_poly_init(r);
gmc_compute(M, &bR, &bC, P, ctxFracQt);
{
fmpz_poly_t t;
fmpz_poly_init(t);
fmpz_poly_set_ui(r, 1);
for (i = 0; i < M->m; i++)
for (j = 0; j < M->n; j++)
{
fmpz_poly_lcm(t, r, fmpz_poly_q_denref(
(fmpz_poly_q_struct *) mat_entry(M, i, j, ctxFracQt)));
fmpz_poly_swap(r, t);
}
fmpz_poly_clear(t);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Gauss-Manin connection:\n");
printf(" r(t) = "), fmpz_poly_print_pretty(r, "t"), printf("\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
{
qadic_t t;
qadic_init2(t, 1);
fmpz_poly_evaluate_qadic(t, r, t1, Qq);
if (qadic_is_zero(t))
{
printf("Exception (deformation_frob).\n");
printf("The resultant r evaluates to zero (mod p) at t1.\n");
abort();
}
qadic_clear(t);
}
/* Precisions ************************************************************/
if (prec_in != NULL)
{
*prec = *prec_in;
}
else
{
deformation_precisions(prec, p, a, n, d, fmpz_poly_degree(r));
}
if (verbose)
{
printf("Precisions:\n");
printf(" N0 = %ld\n", prec->N0);
printf(" N1 = %ld\n", prec->N1);
printf(" N2 = %ld\n", prec->N2);
printf(" N3 = %ld\n", prec->N3);
printf(" N3i = %ld\n", prec->N3i);
printf(" N3w = %ld\n", prec->N3w);
printf(" N3iw = %ld\n", prec->N3iw);
printf(" N4 = %ld\n", prec->N4);
printf(" m = %ld\n", prec->m);
printf(" K = %ld\n", prec->K);
printf(" r = %ld\n", prec->r);
printf(" s = %ld\n", prec->s);
printf("\n");
fflush(stdout);
}
/* Initialisation ********************************************************/
padic_mat_init2(F0, b, b, prec->N4);
fmpz_poly_mat_init(C, b, b);
fmpz_poly_mat_init(Cinv, b, b);
fmpz_poly_mat_init(F, b, b);
vF = 0;
fmpz_poly_mat_init(F1, b, b);
vF1 = 0;
fmpz_poly_init(cp);
/* Step 2 {F0} ***********************************************************/
{
padic_ctx_t pctx_F0;
fmpz *t;
padic_ctx_init(pctx_F0, p, FLINT_MIN(prec->N4 - 10, 0), prec->N4, PADIC_VAL_UNIT);
t = _fmpz_vec_init(n + 1);
c0 = clock();
mpoly_diagonal_fibre(t, P, ctxFracQt);
diagfrob(F0, t, n, d, prec->N4, pctx_F0, 0);
padic_mat_transpose(F0, F0);
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Diagonal fibre:\n");
printf(" P(0) = {"), _fmpz_vec_print(t, n + 1), printf("}\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
_fmpz_vec_clear(t, n + 1);
padic_ctx_clear(pctx_F0);
}
/* Step 3 {C, Cinv} ******************************************************/
/*
Compute C as a matrix over Z_p[[t]]. A is the same but as a series
of matrices over Z_p. Mt is the matrix -M^t, and Cinv is C^{-1}^t,
the local solution of the differential equation replacing M by Mt.
*/
c0 = clock();
{
const long K = prec->K;
padic_mat_struct *A;
gmde_solve(&A, K, p, prec->N3, prec->N3w, M, ctxFracQt);
gmde_convert_soln(C, &vC, A, K, p);
for(i = 0; i < K; i++)
padic_mat_clear(A + i);
free(A);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Local solution:\n");
printf(" Time for C = %f\n", c);
fflush(stdout);
}
c0 = clock();
{
const long K = (prec->K + (*p) - 1) / (*p);
mat_t Mt;
padic_mat_struct *Ainv;
mat_init(Mt, b, b, ctxFracQt);
mat_transpose(Mt, M, ctxFracQt);
mat_neg(Mt, Mt, ctxFracQt);
gmde_solve(&Ainv, K, p, prec->N3i, prec->N3iw, Mt, ctxFracQt);
gmde_convert_soln(Cinv, &vCinv, Ainv, K, p);
fmpz_poly_mat_transpose(Cinv, Cinv);
fmpz_poly_mat_compose_pow(Cinv, Cinv, *p);
for(i = 0; i < K; i++)
padic_mat_clear(Ainv + i);
free(Ainv);
mat_clear(Mt, ctxFracQt);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf(" Time for C^{-1} = %f\n", c);
printf("\n");
fflush(stdout);
}
/* Step 4 {F(t) := C(t) F(0) C(t^p)^{-1}} ********************************/
/*
Computes the product C(t) F(0) C(t^p)^{-1} modulo (p^{N_2}, t^K).
This is done by first computing the unit part of the product
exactly over the integers modulo t^K.
*/
c0 = clock();
{
fmpz_t pN;
fmpz_poly_mat_t T;
fmpz_init(pN);
fmpz_poly_mat_init(T, b, b);
for (i = 0; i < b; i++)
{
/* Find the unique k s.t. F0(i,k) is non-zero */
for (k = 0; k < b; k++)
if (!fmpz_is_zero(padic_mat_entry(F0, i, k)))
break;
if (k == b)
{
printf("Exception (frob). F0 is singular.\n\n");
abort();
}
for (j = 0; j < b; j++)
{
fmpz_poly_scalar_mul_fmpz(fmpz_poly_mat_entry(T, i, j),
fmpz_poly_mat_entry(Cinv, k, j),
padic_mat_entry(F0, i, k));
}
}
fmpz_poly_mat_mul(F, C, T);
fmpz_poly_mat_truncate(F, prec->K);
vF = vC + padic_mat_val(F0) + vCinv;
/* Canonicalise (F, vF) */
{
long v = fmpz_poly_mat_ord_p(F, p);
if (v == LONG_MAX)
{
printf("ERROR (deformation_frob). F(t) == 0.\n");
abort();
}
else if (v > 0)
{
fmpz_pow_ui(pN, p, v);
fmpz_poly_mat_scalar_divexact_fmpz(F, F, pN);
vF = vF + v;
}
}
/* Reduce (F, vF) modulo p^{N2} */
fmpz_pow_ui(pN, p, prec->N2 - vF);
fmpz_poly_mat_scalar_mod_fmpz(F, F, pN);
fmpz_clear(pN);
fmpz_poly_mat_clear(T);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Matrix for F(t):\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
/* Step 5 {G = r(t)^m F(t)} **********************************************/
c0 = clock();
{
fmpz_t pN;
fmpz_poly_t t;
fmpz_init(pN);
fmpz_poly_init(t);
fmpz_pow_ui(pN, p, prec->N2 - vF);
/* Compute r(t)^m mod p^{N2-vF} */
if (prec->denR == NULL)
{
fmpz_mod_poly_t _t;
fmpz_mod_poly_init(_t, pN);
fmpz_mod_poly_set_fmpz_poly(_t, r);
fmpz_mod_poly_pow(_t, _t, prec->m);
fmpz_mod_poly_get_fmpz_poly(t, _t);
fmpz_mod_poly_clear(_t);
}
else
{
/* TODO: We don't really need a copy */
fmpz_poly_set(t, prec->denR);
}
fmpz_poly_mat_scalar_mul_fmpz_poly(F, F, t);
fmpz_poly_mat_scalar_mod_fmpz(F, F, pN);
/* TODO: This should not be necessary? */
fmpz_poly_mat_truncate(F, prec->K);
fmpz_clear(pN);
fmpz_poly_clear(t);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Analytic continuation:\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
/* Steps 6 and 7 *********************************************************/
if (a == 1)
{
/* Step 6 {F(1) = r(t_1)^{-m} G(t_1)} ********************************/
c0 = clock();
{
const long N = prec->N2 - vF;
fmpz_t f, g, t, pN;
fmpz_init(f);
fmpz_init(g);
fmpz_init(t);
fmpz_init(pN);
fmpz_pow_ui(pN, p, N);
/* f := \hat{t_1}, g := r(\hat{t_1})^{-m} */
_padic_teichmuller(f, t1->coeffs + 0, p, N);
if (prec->denR == NULL)
{
_fmpz_mod_poly_evaluate_fmpz(g, r->coeffs, r->length, f, pN);
fmpz_powm_ui(t, g, prec->m, pN);
}
else
{
_fmpz_mod_poly_evaluate_fmpz(t, prec->denR->coeffs, prec->denR->length, f, pN);
}
_padic_inv(g, t, p, N);
/* F1 := g G(\hat{t_1}) */
for (i = 0; i < b; i++)
for (j = 0; j < b; j++)
{
const fmpz_poly_struct *poly = fmpz_poly_mat_entry(F, i, j);
const long len = poly->length;
if (len == 0)
{
fmpz_poly_zero(fmpz_poly_mat_entry(F1, i, j));
}
else
{
fmpz_poly_fit_length(fmpz_poly_mat_entry(F1, i, j), 1);
_fmpz_mod_poly_evaluate_fmpz(t, poly->coeffs, len, f, pN);
fmpz_mul(fmpz_poly_mat_entry(F1, i, j)->coeffs + 0, g, t);
fmpz_mod(fmpz_poly_mat_entry(F1, i, j)->coeffs + 0,
fmpz_poly_mat_entry(F1, i, j)->coeffs + 0, pN);
_fmpz_poly_set_length(fmpz_poly_mat_entry(F1, i, j), 1);
_fmpz_poly_normalise(fmpz_poly_mat_entry(F1, i, j));
}
}
vF1 = vF;
fmpz_poly_mat_canonicalise(F1, &vF1, p);
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(t);
fmpz_clear(pN);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Evaluation:\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
}
else
{
/* Step 6 {F(1) = r(t_1)^{-m} G(t_1)} ********************************/
c0 = clock();
{
const long N = prec->N2 - vF;
fmpz_t pN;
fmpz *f, *g, *t;
fmpz_init(pN);
f = _fmpz_vec_init(a);
g = _fmpz_vec_init(2 * a - 1);
t = _fmpz_vec_init(2 * a - 1);
fmpz_pow_ui(pN, p, N);
/* f := \hat{t_1}, g := r(\hat{t_1})^{-m} */
_qadic_teichmuller(f, t1->coeffs, t1->length, Qq->a, Qq->j, Qq->len, p, N);
if (prec->denR == NULL)
{
fmpz_t e;
fmpz_init_set_ui(e, prec->m);
_fmpz_mod_poly_compose_smod(g, r->coeffs, r->length, f, a,
Qq->a, Qq->j, Qq->len, pN);
_qadic_pow(t, g, a, e, Qq->a, Qq->j, Qq->len, pN);
fmpz_clear(e);
}
else
{
_fmpz_mod_poly_reduce(prec->denR->coeffs, prec->denR->length, Qq->a, Qq->j, Qq->len, pN);
_fmpz_poly_normalise(prec->denR);
_fmpz_mod_poly_compose_smod(t, prec->denR->coeffs, prec->denR->length, f, a,
Qq->a, Qq->j, Qq->len, pN);
}
_qadic_inv(g, t, a, Qq->a, Qq->j, Qq->len, p, N);
/* F1 := g G(\hat{t_1}) */
for (i = 0; i < b; i++)
for (j = 0; j < b; j++)
{
const fmpz_poly_struct *poly = fmpz_poly_mat_entry(F, i, j);
const long len = poly->length;
fmpz_poly_struct *poly2 = fmpz_poly_mat_entry(F1, i, j);
if (len == 0)
{
fmpz_poly_zero(poly2);
}
else
{
_fmpz_mod_poly_compose_smod(t, poly->coeffs, len, f, a,
Qq->a, Qq->j, Qq->len, pN);
fmpz_poly_fit_length(poly2, 2 * a - 1);
_fmpz_poly_mul(poly2->coeffs, g, a, t, a);
_fmpz_mod_poly_reduce(poly2->coeffs, 2 * a - 1, Qq->a, Qq->j, Qq->len, pN);
_fmpz_poly_set_length(poly2, a);
_fmpz_poly_normalise(poly2);
}
}
/* Now the matrix for p^{-1} F_p at t=t_1 is (F1, vF1). */
vF1 = vF;
fmpz_poly_mat_canonicalise(F1, &vF1, p);
fmpz_clear(pN);
_fmpz_vec_clear(f, a);
_fmpz_vec_clear(g, 2 * a - 1);
_fmpz_vec_clear(t, 2 * a - 1);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Evaluation:\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
/* Step 7 {Norm} *****************************************************/
/*
Computes the matrix for $q^{-1} F_q$ at $t = t_1$ as the
product $F \sigma(F) \dotsm \sigma^{a-1}(F)$ up appropriate
transpositions because our convention of columns vs rows is
the opposite of that used by Gerkmann.
Note that, in any case, transpositions do not affect
the characteristic polynomial.
*/
c0 = clock();
{
const long N = prec->N1 - a * vF1;
fmpz_t pN;
fmpz_poly_mat_t T;
fmpz_init(pN);
fmpz_poly_mat_init(T, b, b);
fmpz_pow_ui(pN, p, N);
fmpz_poly_mat_frobenius(T, F1, 1, p, N, Qq);
_qadic_mat_mul(F1, F1, T, pN, Qq);
for (i = 2; i < a; i++)
{
fmpz_poly_mat_frobenius(T, T, 1, p, N, Qq);
_qadic_mat_mul(F1, F1, T, pN, Qq);
}
vF1 = a * vF1;
fmpz_poly_mat_canonicalise(F1, &vF1, p);
fmpz_clear(pN);
fmpz_poly_mat_clear(T);
}
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Norm:\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
}
/* Step 8 {Reverse characteristic polynomial} ****************************/
c0 = clock();
deformation_revcharpoly(cp, F1, vF1, n, d, prec->N0, prec->r, prec->s, Qq);
c1 = clock();
c = (double) (c1 - c0) / CLOCKS_PER_SEC;
if (verbose)
{
printf("Reverse characteristic polynomial:\n");
printf(" p(T) = "), fmpz_poly_print_pretty(cp, "T"), printf("\n");
printf(" Time = %f\n", c);
printf("\n");
fflush(stdout);
}
/* Clean up **************************************************************/
padic_mat_clear(F0);
mat_clear(M, ctxFracQt);
free(bR);
free(bC);
fmpz_poly_clear(r);
fmpz_poly_mat_clear(C);
fmpz_poly_mat_clear(Cinv);
fmpz_poly_mat_clear(F);
fmpz_poly_mat_clear(F1);
fmpz_poly_clear(cp);
}
int
main(void)
{
int i, result;
padic_ctx_t ctx;
fmpz_t p;
slong N;
FLINT_TEST_INIT(state);
flint_printf("mul... ");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000; i++)
{
padic_poly_t a, b, c;
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(b, state, n_randint(state, 50), ctx);
padic_poly_randtest(c, state, n_randint(state, 50), ctx);
padic_poly_mul(a, b, c, ctx);
padic_poly_mul(b, b, c, ctx);
result = (padic_poly_equal(a, b) && padic_poly_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL (aliasing a and b):\n");
padic_poly_print(a, ctx), flint_printf("\n\n");
padic_poly_print(b, 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 aliasing of a and c */
for (i = 0; i < 1000; i++)
{
padic_poly_t a, b, c;
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(b, state, n_randint(state, 50), ctx);
padic_poly_randtest(c, state, n_randint(state, 50), ctx);
padic_poly_mul(a, b, c, ctx);
padic_poly_mul(c, b, c, ctx);
result = (padic_poly_equal(a, c) && padic_poly_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL (aliasing a and c):\n");
padic_poly_print(a, ctx), flint_printf("\n\n");
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 (b * c) + (b * d) = b * (c + d) */
for (i = 0; i < 1000; i++)
{
padic_poly_t a1, a2, b, c, d, t;
slong v;
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(b, 0, N);
padic_poly_init2(c, 0, N);
padic_poly_init2(d, 0, N);
padic_poly_init2(t, 0, N);
padic_poly_randtest(b, state, n_randint(state, 100), ctx);
padic_poly_randtest(c, state, n_randint(state, 100), ctx);
padic_poly_randtest(d, state, n_randint(state, 100), ctx);
v = FLINT_MIN(b->val, c->val);
v = FLINT_MIN(v, d->val);
v = FLINT_MIN(v, 0);
if (v >= 0 || -v < N) /* Otherwise, no precision left */
{
slong N2 = (v >= 0) ? N : N + v;
padic_poly_init2(a1, 0, N2);
padic_poly_init2(a2, 0, N2);
padic_poly_mul(a1, b, c, ctx);
padic_poly_mul(t, b, d, ctx);
padic_poly_add(a1, a1, t, ctx); /* Lower precision */
padic_poly_add(t, c, d, ctx);
padic_poly_mul(a2, b, t, ctx); /* Lower precision */
result = (padic_poly_equal(a1, a2) && padic_poly_is_reduced(a1, ctx));
if (!result)
{
flint_printf("FAIL (distributivity):\n");
flint_printf("p = "), fmpz_print(ctx->p), flint_printf("\n\n");
flint_printf("N = %wd\n\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("d = "), padic_poly_print(d, ctx), flint_printf("\n\n");
flint_printf("a1 = "), padic_poly_print(a1, ctx), flint_printf("\n\n");
flint_printf("a2 = "), padic_poly_print(a2, ctx), flint_printf("\n\n");
abort();
}
padic_poly_clear(a1);
padic_poly_clear(a2);
}
padic_poly_clear(b);
padic_poly_clear(c);
padic_poly_clear(d);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
/* Compare with Q */
for (i = 0; i < 10000; i++)
{
padic_poly_t a, b, c, d;
fmpq_poly_t x, y, z;
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_init2(d, 0, N);
fmpq_poly_init(x);
fmpq_poly_init(y);
fmpq_poly_init(z);
padic_poly_randtest(b, state, n_randint(state, 50), ctx);
padic_poly_randtest(c, state, n_randint(state, 50), ctx);
padic_poly_mul(a, b, c, ctx);
padic_poly_get_fmpq_poly(y, b, ctx);
padic_poly_get_fmpq_poly(z, c, ctx);
fmpq_poly_mul(x, y, z);
padic_poly_set_fmpq_poly(d, x, ctx);
result = (padic_poly_equal(a, d) && padic_poly_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL (cmp with Q):\n");
flint_printf("N = %wd, val(b) = %wd, val(c) = %wd\n", N, b->val, c->val);
padic_poly_print(c, ctx), flint_printf("\n\n");
padic_poly_print(d, ctx), flint_printf("\n\n");
abort();
}
padic_poly_clear(a);
padic_poly_clear(b);
padic_poly_clear(c);
padic_poly_clear(d);
fmpq_poly_clear(x);
fmpq_poly_clear(y);
fmpq_poly_clear(z);
padic_ctx_clear(ctx);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
fmpz_t p;
slong N;
padic_ctx_t ctx;
slong m, n;
FLINT_TEST_INIT(state);
flint_printf("get/ set_entry_padic... ");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
padic_mat_t a;
padic_t x, y;
slong r, c;
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);
m = n_randint(state, 20) + 1;
n = n_randint(state, 20) + 1;
padic_mat_init2(a, m, n, N);
padic_init2(x, N);
padic_init2(y, N);
padic_mat_randtest(a, state, ctx);
padic_randtest_not_zero(x, state, ctx);
r = n_randint(state, m);
c = n_randint(state, n);
padic_mat_set_entry_padic(a, r, c, x, ctx);
padic_mat_get_entry_padic(y, a, r, c, ctx);
result = (padic_equal(x, y) && padic_mat_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), padic_mat_print(a, ctx), flint_printf("\n");
flint_printf("x = "), padic_print(x, ctx), flint_printf("\n");
flint_printf("y = "), padic_print(y, ctx), flint_printf("\n");
abort();
}
padic_mat_clear(a);
padic_clear(x);
padic_clear(y);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
fmpz_t p;
slong N;
padic_ctx_t ctx;
slong m, n;
FLINT_TEST_INIT(state);
flint_printf("scalar_mul_fmpz... ");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
padic_mat_t a, b;
fmpz_t x;
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);
m = n_randint(state, 20);
n = n_randint(state, 20);
padic_mat_init2(a, m, n, N);
padic_mat_init2(b, m, n, N);
fmpz_init(x);
padic_mat_randtest(a, state, ctx);
fmpz_randtest(x, state, 10);
padic_mat_scalar_mul_fmpz(b, a, x, ctx);
padic_mat_scalar_mul_fmpz(a, a, x, ctx);
result = (padic_mat_equal(a, b) && padic_mat_is_reduced(a, ctx));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), padic_mat_print(a, ctx), flint_printf("\n");
flint_printf("b = "), padic_mat_print(b, ctx), flint_printf("\n");
flint_printf("x = "), fmpz_print(x), flint_printf("\n");
abort();
}
padic_mat_clear(a);
padic_mat_clear(b);
fmpz_clear(x);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
_qseive(const mp_limb_t n, const mp_limb_t B)
{
nmod_sparse_mat_t M;
mp_limb_t quad, *quads, *xs, x, i = 0, j, piB = n_prime_pi(B);
const mp_limb_t * ps = n_primes_arr_readonly(piB + 2);
const double * pinvs = n_prime_inverses_arr_readonly(piB + 2);
mzd_t *K;
/* init */
quads = (mp_limb_t *)malloc((piB + 1)*sizeof(mp_limb_t *));
xs = (mp_limb_t *)malloc((piB + 1)*sizeof(mp_limb_t *));
K = mzd_init(piB + 1, 1);
nmod_sparse_mat_init(M, piB + 1, piB + 1, 2);
printf("init done\n");
printf("using %ld primes\n", piB);
/* seive */
for (x = n_sqrt(n), i = 0; i <= piB; x++)
{
quad = x*x - n;
if (quad == 0)
continue;
for (j = 0; j < piB; j++)
n_remove2_precomp(&quad, ps[j], pinvs[j]);
if (quad == 1) /* was B-smooth */
{
quads[i] = x*x - n;
quad = x*x - n;
for (j = 0; j < piB; j++)
{
if (n_remove2_precomp(&quad, ps[j], pinvs[j]) % 2)
_nmod_sparse_mat_set_entry(M, j, i, M->row_supports[j], 1);
}
xs[i] = x;
i++;
}
}
printf("data collection done\n");
n_cleanup_primes();
_bw(K, M, 1, 2, 7, 7);
printf("procesing complete\n");
mzd_print(K);
int done = 0;
for (j = 0; !done; j++)
{
fmpz_t a, b, diff, N;
fmpz_init_set_ui(a, 1);
fmpz_init_set_ui(b, 1);
fmpz_init_set_ui(N, n);
fmpz_init(diff);
for (i = 0; i < piB; i++)
{
if (mzd_read_bit(K, i, j))
{
fmpz_mul_ui(a, a, xs[i]);
fmpz_mul_ui(b, b, quads[i]);
}
}
assert(fmpz_is_square(b));
fmpz_sqrt(b, b);
if (fmpz_mod_ui(a, a, n) != fmpz_mod_ui(b, b, n) && fmpz_mod_ui(a, a, n) != n - fmpz_mod_ui(b, b, n))
{
done = 1;
fmpz_print(a);
printf("\n");
fmpz_print(b);
printf("\n");
fmpz_sub(diff, a, b);
fmpz_gcd(a, diff, N);
fmpz_divexact(b, N, a);
fmpz_print(a);
printf("\n");
fmpz_print(b);
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(N);
fmpz_clear(diff);
}
/* cleanup */
free(quads);
free(xs);
mzd_free(K);
nmod_sparse_mat_clear(M);
return;
}
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 iter;
FLINT_TEST_INIT(state);
flint_printf("factor_squarefree....");
fflush(stdout);
for (iter = 0; iter < 300; iter++)
{
int result = 1;
fmpz_mod_poly_t pol1, poly, quot, rem;
fmpz_mod_poly_factor_t res;
fmpz_t modulus;
slong exp[5], prod1;
slong length, i, j, num;
fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
fmpz_mod_poly_init(pol1, modulus);
fmpz_mod_poly_init(poly, modulus);
fmpz_mod_poly_init(quot, modulus);
fmpz_mod_poly_init(rem, modulus);
fmpz_mod_poly_zero(pol1);
fmpz_mod_poly_set_coeff_ui(pol1, 0, 1);
length = n_randint(state, 7) + 2;
do
{
fmpz_mod_poly_randtest(poly, state, length);
fmpz_mod_poly_make_monic(poly, poly);
}
while ((!fmpz_mod_poly_is_irreducible(poly)) || (poly->length < 2));
exp[0] = n_randprime(state, 5, 0);
prod1 = exp[0];
for (i = 0; i < exp[0]; i++)
fmpz_mod_poly_mul(pol1, pol1, poly);
num = n_randint(state, 5) + 1;
for (i = 1; i < num; i++)
{
do
{
length = n_randint(state, 7) + 2;
fmpz_mod_poly_randtest(poly, state, length);
if (poly->length)
{
fmpz_mod_poly_make_monic(poly, poly);
fmpz_mod_poly_divrem(quot, rem, pol1, poly);
}
}
while ((!fmpz_mod_poly_is_irreducible(poly)) ||
(poly->length < 2) || (rem->length == 0));
do
exp[i] = n_randprime(state, 5, 0);
while (prod1 % exp[i] == 0);
prod1 *= exp[i];
for (j = 0; j < exp[i]; j++)
fmpz_mod_poly_mul(pol1, pol1, poly);
}
fmpz_mod_poly_factor_init(res);
fmpz_mod_poly_factor_squarefree(res, pol1);
result &= (res->num == num);
if (result)
{
ulong prod2 = 1;
for (i = 0; i < num; i++)
prod2 *= res->exp[i];
result &= (prod1 == prod2);
}
if (!result)
{
flint_printf("Error: exp don't match. Modulus = ");
fmpz_print(modulus);
flint_printf("\n");
for (i = 0; i < res->num; i++)
flint_printf("%wd ", res->exp[i]);
flint_printf("\n");
for (i = 0; i < num; i++)
flint_printf("%wd ", exp[i]);
flint_printf("\n");
abort();
}
fmpz_clear(modulus);
fmpz_mod_poly_clear(quot);
fmpz_mod_poly_clear(rem);
fmpz_mod_poly_clear(pol1);
fmpz_mod_poly_clear(poly);
fmpz_mod_poly_factor_clear(res);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
/*
Computes the rising factorial $\prod_{i=0}^{n-1} (x+i) mod m$.
*/
void fmpz_mod_rfac_uiui(fmpz_t r, ulong x, ulong n, const fmpz_t m)
{
if (fmpz_sgn(m) <= 0)
{
printf("Exception (fmpz_mod_rfac_uiui). m < 0.");
abort();
}
if (fmpz_is_one(m))
{
fmpz_zero(r);
}
else if (n == 0)
{
fmpz_one(r);
}
else if (n == 1)
{
fmpz_set_ui(r, x);
fmpz_mod(r, r, m);
}
else if (x == 0)
{
fmpz_zero(r);
}
else /* m > 1, n > 1, x > 0 */
{
/*
Choose l such that we can multiple l factors in
this rising factorial without overflow mod m
*/
ulong i, l;
/* Set l = log_2(x + n - 1), avoiding overflow */
{
fmpz_t t;
fmpz_init_set_ui(t, x);
fmpz_add_ui(t, t, n - 1);
l = fmpz_clog_ui(t, 2);
fmpz_clear(t);
}
l = (fmpz_clog_ui(m, 2) + (l - 1)) / l - 1;
if (l > 1)
{
fmpz_t t;
fmpz_init(t);
fmpz_rfac_uiui(r, x, n % l);
for (i = n % l; i < n; i += l)
{
fmpz_rfac_uiui(t, x + i, l);
fmpz_mul(r, r, t);
fmpz_mod(r, r, m);
}
fmpz_clear(t);
}
else
{
fmpz_set_ui(r, x);
fmpz_mod(r, r, m);
for (i = 1; i < n; i++)
{
fmpz_mul_ui(r, r, x + i);
fmpz_mod(r, r, m);
}
}
}
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("log... ");
fflush(stdout);
/** p == 2 *******************************************************************/
/* Check aliasing: a = log(a) */
for (i = 0; i < 1000; i++)
{
fmpz_t p = {WORD(2)};
slong N;
padic_ctx_t ctx;
padic_t a, b;
int ans1, ans2;
N = __rand_prec(state, i);
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_init2(a, N);
padic_init2(b, N);
padic_randtest(a, state, ctx);
padic_one(b);
padic_add(a, a, b, ctx);
ans1 = padic_log(b, a, ctx);
ans2 = padic_log(a, a, ctx);
result = (ans1 == ans2) && (!ans1 || padic_equal(a, b));
if (!result)
{
flint_printf("FAIL (aliasing):\n\n");
flint_printf("a = "), padic_print(a, ctx), flint_printf("\n");
flint_printf("b = "), padic_print(b, ctx), flint_printf("\n");
abort();
}
padic_clear(a);
padic_clear(b);
padic_ctx_clear(ctx);
}
/* Check: log(a) + log(b) == log(a * b) */
for (i = 0; i < 10000; i++)
{
fmpz_t p = {WORD(2)};
slong N;
padic_ctx_t ctx;
padic_t a, b, c, d, e, f, g;
int ans1, ans2, ans3;
N = __rand_prec(state, i);
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_init2(a, N);
padic_init2(b, N);
padic_init2(c, N);
padic_init2(d, N);
padic_init2(e, N);
padic_init2(f, N);
padic_init2(g, N);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_one(c);
padic_add(a, a, c, ctx);
padic_add(b, b, c, ctx);
padic_mul(c, a, b, ctx);
ans1 = padic_log(d, a, ctx);
ans2 = padic_log(e, b, ctx);
padic_add(f, d, e, ctx);
ans3 = padic_log(g, c, ctx);
result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g)));
if (!result)
{
flint_printf("FAIL (functional equation):\n\n");
flint_printf("a = "), padic_print(a, ctx), flint_printf("\n");
flint_printf("b = "), padic_print(b, ctx), flint_printf("\n");
flint_printf("c = a * b = "), padic_print(c, ctx), flint_printf("\n");
flint_printf("d = log(a) = "), padic_print(d, ctx), flint_printf("\n");
flint_printf("e = log(b) = "), padic_print(e, ctx), flint_printf("\n");
flint_printf("f = log(a) + log(b) = "), padic_print(f, ctx), flint_printf("\n");
flint_printf("g = log(a * b) = "), padic_print(g, ctx), flint_printf("\n");
abort();
}
padic_clear(a);
padic_clear(b);
padic_clear(c);
padic_clear(d);
padic_clear(e);
padic_clear(f);
padic_clear(g);
padic_ctx_clear(ctx);
}
/* Check: log(exp(x)) == x */
for (i = 0; i < 10000; i++)
{
fmpz_t p = {WORD(2)};
slong N;
padic_ctx_t ctx;
padic_t a, b, c;
int ans1, ans2;
N = __rand_prec(state, i);
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_init2(a, N);
padic_init2(b, N);
padic_init2(c, N);
padic_randtest(a, state, ctx);
ans1 = padic_exp(b, a, ctx);
if (ans1)
ans2 = padic_log(c, b, ctx);
result = !ans1 || (ans1 == ans2 && padic_equal(a, c));
if (!result)
{
flint_printf("FAIL (log(exp(x)) == x):\n\n");
flint_printf("a = "), padic_print(a, ctx), flint_printf("\n");
flint_printf("b = "), padic_print(b, ctx), flint_printf("\n");
flint_printf("c = "), padic_print(c, ctx), flint_printf("\n");
flint_printf("ans1 = %d\n", ans1);
flint_printf("ans2 = %d\n", ans2);
abort();
}
padic_clear(a);
padic_clear(b);
padic_clear(c);
padic_ctx_clear(ctx);
}
/** p > 2 ********************************************************************/
/* Check aliasing: a = log(a) */
for (i = 0; i < 1000; i++)
{
fmpz_t p;
slong N;
padic_ctx_t ctx;
padic_t a, b;
int ans1, ans2;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = __rand_prec(state, i);
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_init2(a, N);
padic_init2(b, N);
padic_randtest(a, state, ctx);
padic_one(b);
padic_add(a, a, b, ctx);
ans1 = padic_log(b, a, ctx);
ans2 = padic_log(a, a, ctx);
result = (ans1 == ans2) && (!ans1 || padic_equal(a, b));
if (!result)
{
flint_printf("FAIL (aliasing):\n\n");
flint_printf("a = "), padic_print(a, ctx), flint_printf("\n");
flint_printf("b = "), padic_print(b, ctx), flint_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;
slong N;
padic_ctx_t ctx;
padic_t a, b, c, d, e, f, g;
int ans1, ans2, ans3;
/* fmpz_init_set_ui(p, n_randtest_prime(state, 0)); */
fmpz_init_set_ui(p, n_randprime(state, 5, 1));
N = __rand_prec(state, i);
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_init2(a, N);
padic_init2(b, N);
padic_init2(c, N);
padic_init2(d, N);
padic_init2(e, N);
padic_init2(f, N);
padic_init2(g, N);
padic_randtest(a, state, ctx);
padic_randtest(b, state, ctx);
padic_one(c);
padic_add(a, a, c, ctx);
padic_one(c);
padic_add(b, b, c, ctx);
padic_mul(c, a, b, ctx);
ans1 = padic_log(d, a, ctx);
ans2 = padic_log(e, b, ctx);
padic_add(f, d, e, ctx);
ans3 = padic_log(g, c, ctx);
result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g)));
if (!result)
{
flint_printf("FAIL (functional equation):\n\n");
flint_printf("a = "), padic_print(a, ctx), flint_printf("\n");
flint_printf("b = "), padic_print(b, ctx), flint_printf("\n");
flint_printf("c = a * b = "), padic_print(c, ctx), flint_printf("\n");
flint_printf("d = log(a) = "), padic_print(d, ctx), flint_printf("\n");
flint_printf("e = log(b) = "), padic_print(e, ctx), flint_printf("\n");
flint_printf("f = log(a) + log(b) = "), padic_print(f, ctx), flint_printf("\n");
flint_printf("g = log(a * b) = "), padic_print(g, ctx), flint_printf("\n");
flint_printf("ans1 = %d\n", ans1);
flint_printf("ans2 = %d\n", ans2);
flint_printf("ans3 = %d\n", ans3);
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;
slong N;
padic_ctx_t ctx;
padic_t a, b, c;
int ans1, ans2;
fmpz_init_set_ui(p, n_randtest_prime(state, 0));
N = __rand_prec(state, i);
padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES);
padic_init2(a, N);
padic_init2(b, N);
padic_init2(c, N);
padic_randtest(a, state, ctx);
ans1 = padic_exp(b, a, ctx);
if (ans1)
ans2 = padic_log(c, b, ctx);
result = !ans1 || (ans1 == ans2 && padic_equal(a, c));
if (!result)
{
flint_printf("FAIL (log(exp(x)) == x):\n\n");
flint_printf("a = "), padic_print(a, ctx), flint_printf("\n");
flint_printf("b = "), padic_print(b, ctx), flint_printf("\n");
flint_printf("c = "), padic_print(c, ctx), flint_printf("\n");
flint_printf("ans1 = %d\n", ans1);
flint_printf("ans2 = %d\n", ans2);
abort();
}
padic_clear(a);
padic_clear(b);
padic_clear(c);
fmpz_clear(p);
padic_ctx_clear(ctx);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mul... ");
fflush(stdout);
/* Check aliasing: a = a * b */
for (i = 0; i < 2000; i++)
{
fmpz_t p;
slong d, N;
qadic_ctx_t ctx;
qadic_t a, b, c;
fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
d = n_randint(state, 10) + 1;
N = z_randint(state, 50) + 1;
qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);
qadic_init2(a, N);
qadic_init2(b, N);
qadic_init2(c, N);
qadic_randtest(a, state, ctx);
qadic_randtest(b, state, ctx);
qadic_mul(c, a, b, ctx);
qadic_mul(a, a, b, ctx);
result = (qadic_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n");
flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n");
abort();
}
qadic_clear(a);
qadic_clear(b);
qadic_clear(c);
fmpz_clear(p);
qadic_ctx_clear(ctx);
}
/* Check aliasing: b = a * b */
for (i = 0; i < 2000; i++)
{
fmpz_t p;
slong d, N;
qadic_ctx_t ctx;
qadic_t a, b, c;
fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
d = n_randint(state, 10) + 1;
N = z_randint(state, 50) + 1;
qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), "a", PADIC_SERIES);
qadic_init2(a, N);
qadic_init2(b, N);
qadic_init2(c, N);
qadic_randtest(a, state, ctx);
qadic_randtest(b, state, ctx);
qadic_mul(c, a, b, ctx);
qadic_mul(b, a, b, ctx);
result = (qadic_equal(b, c));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n");
flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n");
abort();
}
qadic_clear(a);
qadic_clear(b);
qadic_clear(c);
fmpz_clear(p);
qadic_ctx_clear(ctx);
}
/* Check aliasing: a = a + a */
for (i = 0; i < 2000; i++)
{
fmpz_t p;
slong d, N;
qadic_ctx_t ctx;
qadic_t a, c;
fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
d = n_randint(state, 10) + 1;
N = z_randint(state, 50) + 1;
qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);
qadic_init2(a, N);
qadic_init2(c, N);
qadic_randtest(a, state, ctx);
qadic_add(c, a, a, ctx);
qadic_add(a, a, a, ctx);
result = (qadic_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n");
abort();
}
qadic_clear(a);
qadic_clear(c);
fmpz_clear(p);
qadic_ctx_clear(ctx);
}
/* Check that a * b == b * a */
for (i = 0; i < 2000; i++)
{
fmpz_t p;
slong d, N;
qadic_ctx_t ctx;
qadic_t a, b, c1, c2;
fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
d = n_randint(state, 10) + 1;
N = z_randint(state, 50) + 1;
qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);
qadic_init2(a, N);
qadic_init2(b, N);
qadic_init2(c1, N);
qadic_init2(c2, N);
qadic_randtest(a, state, ctx);
qadic_randtest(b, state, ctx);
qadic_mul(c1, a, b, ctx);
qadic_mul(c2, b, a, ctx);
result = (qadic_equal(c1, c2));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n");
flint_printf("c1 = "), qadic_print_pretty(c1, ctx), flint_printf("\n");
flint_printf("c2 = "), qadic_print_pretty(c2, ctx), flint_printf("\n");
abort();
}
qadic_clear(a);
qadic_clear(b);
qadic_clear(c1);
qadic_clear(c2);
fmpz_clear(p);
qadic_ctx_clear(ctx);
}
/* Check that (a * b) * c == a * (b * c) for integral values */
for (i = 0; i < 2000; i++)
{
fmpz_t p;
slong d, N;
qadic_ctx_t ctx;
qadic_t a, b, c, lhs, rhs;
fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
d = n_randint(state, 10) + 1;
N = n_randint(state, 50) + 1;
qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);
qadic_init2(a, N);
qadic_init2(b, N);
qadic_init2(c, N);
qadic_init2(lhs, N);
qadic_init2(rhs, N);
qadic_randtest_int(a, state, ctx);
qadic_randtest_int(b, state, ctx);
qadic_randtest_int(c, state, ctx);
qadic_mul(lhs, a, b, ctx);
qadic_mul(lhs, lhs, c, ctx);
qadic_mul(rhs, b, c, ctx);
qadic_mul(rhs, a, rhs, ctx);
result = (qadic_equal(lhs, rhs));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n");
flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n");
flint_printf("lhs = "), qadic_print_pretty(lhs, ctx), flint_printf("\n");
flint_printf("rhs = "), qadic_print_pretty(rhs, ctx), flint_printf("\n");
abort();
}
qadic_clear(a);
qadic_clear(b);
qadic_clear(c);
qadic_clear(lhs);
qadic_clear(rhs);
fmpz_clear(p);
qadic_ctx_clear(ctx);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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("hensel_start_continue_lift....");
fflush(stdout);
flint_randinit(state);
/* We check that lifting local factors of F yields factors */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t F, G, H, R;
nmod_poly_factor_t f_fac;
fmpz_poly_factor_t F_fac;
long bits, nbits, n, exp, j, part_exp;
long r;
fmpz_poly_t *v, *w;
long *link;
long prev_exp;
bits = n_randint(state, 200) + 1;
nbits = n_randint(state, FLINT_BITS - 6) + 6;
fmpz_poly_init(F);
fmpz_poly_init(G);
fmpz_poly_init(H);
fmpz_poly_init(R);
nmod_poly_factor_init(f_fac);
fmpz_poly_factor_init(F_fac);
n = n_randprime(state, nbits, 0);
exp = bits / (FLINT_BIT_COUNT(n) - 1) + 1;
part_exp = n_randint(state, exp);
/* Produce F as the product of random G and H */
{
nmod_poly_t f;
nmod_poly_init(f, n);
do {
do {
fmpz_poly_randtest(G, state, n_randint(state, 200) + 2, bits);
} while (G->length < 2);
fmpz_randtest_not_zero(G->coeffs, state, bits);
fmpz_one(fmpz_poly_lead(G));
do {
fmpz_poly_randtest(H, state, n_randint(state, 200) + 2, bits);
} while (H->length < 2);
fmpz_randtest_not_zero(H->coeffs, state, bits);
fmpz_one(fmpz_poly_lead(H));
fmpz_poly_mul(F, G, H);
fmpz_poly_get_nmod_poly(f, F);
} while (!nmod_poly_is_squarefree(f));
fmpz_poly_get_nmod_poly(f, G);
nmod_poly_factor_insert(f_fac, f, 1);
fmpz_poly_get_nmod_poly(f, H);
nmod_poly_factor_insert(f_fac, f, 1);
nmod_poly_clear(f);
}
r = f_fac->num;
v = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t));
w = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t));
link = flint_malloc((2*r - 2)*sizeof(long));
for (j = 0; j < 2*r - 2; j++)
{
fmpz_poly_init(v[j]);
fmpz_poly_init(w[j]);
}
if (part_exp < 1)
{
_fmpz_poly_hensel_start_lift(F_fac, link, v, w, F, f_fac, exp);
}
else
{
fmpz_t nn;
fmpz_init_set_ui(nn, n);
prev_exp = _fmpz_poly_hensel_start_lift(F_fac, link, v, w,
F, f_fac, part_exp);
_fmpz_poly_hensel_continue_lift(F_fac, link, v, w,
F, prev_exp, part_exp, exp, nn);
fmpz_clear(nn);
}
result = 1;
for (j = 0; j < F_fac->num; j++)
{
fmpz_poly_rem(R, F, F_fac->p + j);
result &= (R->length == 0);
}
for (j = 0; j < 2*r - 2; j++)
{
fmpz_poly_clear(v[j]);
fmpz_poly_clear(w[j]);
}
flint_free(link);
flint_free(v);
flint_free(w);
if (!result)
{
printf("FAIL:\n");
printf("bits = %ld, n = %ld, exp = %ld\n", bits, n, exp);
fmpz_poly_print(F); printf("\n\n");
fmpz_poly_print(G); printf("\n\n");
fmpz_poly_print(H); printf("\n\n");
fmpz_poly_factor_print(F_fac); printf("\n\n");
abort();
}
nmod_poly_factor_clear(f_fac);
fmpz_poly_factor_clear(F_fac);
fmpz_poly_clear(F);
fmpz_poly_clear(H);
fmpz_poly_clear(G);
fmpz_poly_clear(R);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}