int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("swap....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b, c;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(c, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest(b, state, n_randint(state, 100));
fmpz_mod_poly_set(c, b);
fmpz_mod_poly_swap(a, b);
result = (fmpz_mod_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_mod_poly_print(a), flint_printf("\n\n");
fmpz_mod_poly_print(b), flint_printf("\n\n");
fmpz_mod_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(c);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
fmpz_mod_poly_shift_right(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, long n)
{
if (n == 0)
{
fmpz_mod_poly_set(res, poly);
return;
}
if (poly->length <= n)
{
fmpz_mod_poly_zero(res);
return;
}
fmpz_mod_poly_fit_length(res, poly->length - n);
_fmpz_mod_poly_shift_right(res->coeffs, poly->coeffs, poly->length, n);
_fmpz_mod_poly_set_length(res, poly->length - n);
}
void fmpz_mod_poly_divrem_f(fmpz_t f, fmpz_mod_poly_t Q, fmpz_mod_poly_t R,
const fmpz_mod_poly_t A, const fmpz_mod_poly_t B)
{
const slong lenA = A->length;
const slong lenB = B->length;
const slong lenQ = lenA - lenB + 1;
fmpz *q, *r;
fmpz_t invB;
fmpz_init(invB);
fmpz_gcdinv(f, invB, fmpz_poly_lead(B), &(B->p));
if (!fmpz_is_one(f))
{
fmpz_clear(invB);
return;
}
if (lenA < lenB)
{
fmpz_mod_poly_set(R, A);
fmpz_mod_poly_zero(Q);
fmpz_clear(invB);
return;
}
if (Q == A || Q == B)
{
q = _fmpz_vec_init(lenQ);
}
else
{
fmpz_mod_poly_fit_length(Q, lenQ);
q = Q->coeffs;
}
if (R == A || R == B)
{
r = _fmpz_vec_init(lenA);
}
else
{
fmpz_mod_poly_fit_length(R, lenA);
r = R->coeffs;
}
_fmpz_mod_poly_divrem_divconquer(q, r, A->coeffs, lenA,
B->coeffs, lenB, invB, &(B->p));
if (Q == A || Q == B)
{
_fmpz_vec_clear(Q->coeffs, Q->alloc);
Q->coeffs = q;
Q->alloc = lenQ;
Q->length = lenQ;
}
else
{
_fmpz_mod_poly_set_length(Q, lenQ);
}
if (R == A || R == B)
{
_fmpz_vec_clear(R->coeffs, R->alloc);
R->coeffs = r;
R->alloc = lenA;
R->length = lenA;
}
_fmpz_mod_poly_set_length(R, lenB - 1);
_fmpz_mod_poly_normalise(R);
fmpz_clear(invB);
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("pow_trunc....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
fmpz_mod_poly_t a, b, c;
fmpz_t p;
slong e, trunc;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(c, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 30));
e = n_randint(state, 20);
trunc = n_randint(state, 30);
fmpz_mod_poly_set(c, a);
fmpz_mod_poly_pow_trunc(b, a, e, trunc);
fmpz_mod_poly_pow_trunc(c, c, e, trunc);
result = (fmpz_mod_poly_equal(b, c));
if (!result)
{
flint_printf("FAIL aliasing:\n");
flint_printf("a->length = %wd, p = %wu, exp = %wd, trunc = %wd\n",
a->length, a->p, e, trunc);
flint_printf("a:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n");
flint_printf("b:\n"); fmpz_mod_poly_print(b), flint_printf("\n\n");
flint_printf("c:\n"); fmpz_mod_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_clear(p);
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(c);
}
/* Check powering against naive method */
for (i = 0; i < 10000; i++)
{
fmpz_mod_poly_t a, b, c;
fmpz_t p;
slong e, trunc;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(c, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 30));
e = n_randint(state, 20);
trunc = n_randint(state, 30);
fmpz_mod_poly_pow_trunc(b, a, e, trunc);
fmpz_mod_poly_pow(c, a, e);
fmpz_mod_poly_truncate(c, trunc);
result = (fmpz_mod_poly_equal(b, c)
|| (a->length == 0 && e == 0 && c->length == 1 && c->coeffs[0] == 1));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a->length = %wd, p = %wu, exp = %wd, trunc = %wd\n",
a->length, a->p, e, trunc);
flint_printf("a:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n");
flint_printf("b:\n"); fmpz_mod_poly_print(b), flint_printf("\n\n");
flint_printf("c:\n"); fmpz_mod_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_clear(p);
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("derivative....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b, c;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(c, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_set(b, a);
fmpz_mod_poly_derivative(c, b);
fmpz_mod_poly_derivative(b, b);
result = (fmpz_mod_poly_equal(b, c));
if (!result)
{
printf("FAIL (alias):\n");
fmpz_mod_poly_print(a), printf("\n\n");
fmpz_mod_poly_print(b), printf("\n\n");
fmpz_mod_poly_print(c), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(c);
fmpz_clear(p);
}
/* Check constants have derivative zero */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 2));
fmpz_mod_poly_derivative(b, a);
result = (b->length == 0);
if (!result)
{
printf("FAIL (da == 0):\n");
fmpz_mod_poly_print(a), printf("\n\n");
fmpz_mod_poly_print(b), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_clear(p);
}
/* Check (f g)' = f' g + f g' */
for (i = 0; i < 10000; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b, c, d, lhs, rhs;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(c, p);
fmpz_mod_poly_init(d, p);
fmpz_mod_poly_init(lhs, p);
fmpz_mod_poly_init(rhs, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest(b, state, n_randint(state, 100));
fmpz_mod_poly_mul(lhs, a, b);
fmpz_mod_poly_derivative(lhs, lhs);
fmpz_mod_poly_derivative(c, a);
fmpz_mod_poly_derivative(d, b);
fmpz_mod_poly_mul(c, c, b);
fmpz_mod_poly_mul(d, a, d);
fmpz_mod_poly_add(rhs, c, d);
result = fmpz_mod_poly_equal(lhs, rhs);
if (!result)
{
printf("FAIL (Leibniz):\n");
printf("a = "), fmpz_mod_poly_print(a), printf("\n\n");
printf("b = "), fmpz_mod_poly_print(b), printf("\n\n");
printf("(ab)' = "), fmpz_mod_poly_print(lhs), printf("\n\n");
printf("a'b + ab' = "), fmpz_mod_poly_print(rhs), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(c);
fmpz_mod_poly_clear(d);
fmpz_mod_poly_clear(lhs);
fmpz_mod_poly_clear(rhs);
fmpz_clear(p);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int fmpz_mod_poly_is_irreducible_ddf(const fmpz_mod_poly_t poly)
{
fmpz_mod_poly_t f, v, vinv, reducedH0, tmp;
fmpz_mod_poly_t *h, *H, *I;
slong i, j, l, m, n, d;
fmpz_t p;
double beta;
int result = 1;
n = fmpz_mod_poly_degree(poly);
if (n < 2)
return 1;
if (!fmpz_mod_poly_is_squarefree(poly))
return 0;
beta = 0.5 * (1. - (log(2) / log(n)));
l = ceil(pow(n, beta));
m = ceil(0.5 * n / l);
/* initialization */
fmpz_init(p);
fmpz_set(p, &poly->p);
fmpz_mod_poly_init(f, p);
fmpz_mod_poly_init(v, p);
fmpz_mod_poly_init(vinv, p);
fmpz_mod_poly_init(reducedH0, p);
fmpz_mod_poly_init(tmp, p);
if (!(h = flint_malloc((2 * m + l + 1) * sizeof(fmpz_mod_poly_struct))))
{
flint_printf("Exception (fmpz_mod_poly_is_irreducible_ddf): \n");
flint_printf("Not enough memory.\n");
abort();
}
H = h + (l + 1);
I = H + m;
for (i = 0; i < l + 1; i++)
fmpz_mod_poly_init(h[i], p);
for (i = 0; i < m; i++)
{
fmpz_mod_poly_init(H[i], p);
fmpz_mod_poly_init(I[i], p);
}
fmpz_mod_poly_make_monic(v, poly);
fmpz_mod_poly_reverse (vinv, v, v->length);
fmpz_mod_poly_inv_series_newton (vinv, vinv, v->length);
/* compute baby steps: h[i]=x^{p^i}mod v */
fmpz_mod_poly_set_coeff_ui(h[0], 1, 1);
for (i = 1; i < l + 1; i++)
fmpz_mod_poly_powmod_fmpz_binexp_preinv(h[i], h[i - 1], p, v, vinv);
/* compute coarse distinct-degree factorisation */
fmpz_mod_poly_set(H[0], h[l]);
fmpz_mod_poly_set(reducedH0, H[0]);
d = 1;
for (j = 0; j < m; j++)
{
/* compute giant steps: H[i]=x^{p^(li)}mod v */
if (j > 0)
{
fmpz_mod_poly_rem (reducedH0, reducedH0, v);
fmpz_mod_poly_rem (tmp, H[j-1], v);
fmpz_mod_poly_compose_mod_brent_kung_preinv(H[j], tmp, reducedH0,
v, vinv);
}
/* compute interval polynomials */
fmpz_mod_poly_set_coeff_ui(I[j], 0, 1);
for (i = l - 1; (i >= 0) && (2*d <= v->length - 1); i--, d++)
{
fmpz_mod_poly_rem(tmp, h[i], v);
fmpz_mod_poly_sub(tmp, H[j], tmp);
fmpz_mod_poly_mulmod_preinv (I[j], tmp, I[j], v, vinv);
}
/* compute F_j=f^{[j*l+1]} * ... * f^{[j*l+l]} */
/* F_j is stored on the place of I_j */
fmpz_mod_poly_gcd(I[j], v, I[j]);
if (I[j]->length > 1)
{
result = 0;
break;
}
}
fmpz_clear(p);
fmpz_mod_poly_clear(f);
fmpz_mod_poly_clear(reducedH0);
fmpz_mod_poly_clear(v);
fmpz_mod_poly_clear(vinv);
fmpz_mod_poly_clear(tmp);
for (i = 0; i < l + 1; i++)
fmpz_mod_poly_clear(h[i]);
for (i = 0; i < m; i++)
{
fmpz_mod_poly_clear(H[i]);
fmpz_mod_poly_clear(I[i]);
}
flint_free(h);
return result;
}
void fmpz_mod_poly_radix(fmpz_mod_poly_struct **B,
const fmpz_mod_poly_t F,
const fmpz_mod_poly_radix_t D)
{
const long lenF = F->length;
const long degF = F->length - 1;
const long degR = D->degR;
const long N = degF / degR;
if (N == 0)
{
fmpz_mod_poly_set(B[0], F);
}
else
{
const long k = FLINT_BIT_COUNT(N); /* k := ceil{log{N+1}} */
const long lenG = (1L << k) * degR; /* Padded size */
const long t = (lenG - 1) / degR - N; /* Extra {degR}-blocks */
fmpz *G; /* Padded copy of F */
fmpz *T; /* Additional B[i] */
fmpz **C; /* Enlarged version of B */
fmpz *W; /* Temporary space */
long i;
if (lenF < lenG)
{
G = flint_malloc(lenG * sizeof(fmpz));
for (i = 0; i < lenF; i++)
G[i] = F->coeffs[i];
mpn_zero((mp_ptr) G + lenF, lenG - lenF);
T = t ? _fmpz_vec_init(t * degR) : NULL;
}
else /* lenF == lenG */
{
G = F->coeffs;
T = NULL;
}
C = flint_malloc((N + 1 + t) * sizeof(fmpz *));
for (i = 0; i <= N; i++)
{
fmpz_mod_poly_fit_length(B[i], degR);
C[i] = B[i]->coeffs;
}
for (i = 0; i < t; i++)
{
C[N + 1 + i] = T + i * degR;
}
W = _fmpz_vec_init(lenG);
_fmpz_mod_poly_radix(C, G, D->Rpow, D->Rinv, degR, 0, k-1, W, &(F->p));
_fmpz_vec_clear(W, lenG);
for (i = 0; i <= N; i++)
{
_fmpz_mod_poly_set_length(B[i], degR);
_fmpz_mod_poly_normalise(B[i]);
}
flint_free(C);
if (lenF < lenG)
{
flint_free(G);
}
if (t)
{
_fmpz_vec_clear(T, t * degR);
}
}
}
