int
main(void)
{
int i, result;
ulong j;
FLINT_TEST_INIT(state);
flint_printf("get/set_coeff_ui....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t a;
mp_limb_t n = n_randtest_not_zero(state);
mp_limb_t c1 = n_randtest(state), c2;
j = n_randint(state, 100);
nmod_poly_init(a, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_set_coeff_ui(a, j, c1);
c2 = nmod_poly_get_coeff_ui(a, j);
result = (c2 == c1 % n);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("j = %wu, c1 = %wu, c2 = %wu, n = %wu\n", j, c1, c2, a->mod.n);
nmod_poly_print(a), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("revert_series....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 100; i++)
{
nmod_poly_t f, g;
mp_limb_t m;
long n;
m = n_randtest_prime(state, 0);
nmod_poly_init(f, m);
nmod_poly_init(g, m);
do {
nmod_poly_randtest(g, state, n_randint(state, 100));
} while (nmod_poly_get_coeff_ui(g, 1) == 0);
nmod_poly_set_coeff_ui(g, 0, 0);
do {
n = n_randint(state, 100);
} while (n >= m);
nmod_poly_revert_series(f, g, n);
nmod_poly_revert_series(g, g, n);
result = (nmod_poly_equal(f, g));
if (!result)
{
printf("FAIL (aliasing):\n");
nmod_poly_print(f), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
abort();
}
nmod_poly_clear(f);
nmod_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 1000; i++)
{
nmod_poly_t f, g, h;
mp_limb_t m;
long n;
m = n_randtest_prime(state, 0);
nmod_poly_init(f, m);
nmod_poly_init(g, m);
nmod_poly_init(h, m);
do {
nmod_poly_randtest(g, state, n_randint(state, 100));
} while (nmod_poly_get_coeff_ui(g, 1) == 0);
nmod_poly_set_coeff_ui(g, 0, 0);
do {
n = n_randint(state, 100);
} while (n >= m);
nmod_poly_revert_series(f, g, n);
nmod_poly_compose_series(h, g, f, n);
result = ((n <= 1 && nmod_poly_is_zero(h)) ||
(h->length == 2 && h->coeffs[0] == 0 && h->coeffs[1] == 1));
if (!result)
{
printf("FAIL (comparison):\n");
nmod_poly_print(g), printf("\n\n");
nmod_poly_print(f), printf("\n\n");
nmod_poly_print(h), printf("\n\n");
abort();
}
nmod_poly_clear(f);
nmod_poly_clear(g);
nmod_poly_clear(h);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
void
nmod_poly_factor_squarefree(nmod_poly_factor_t res, const nmod_poly_t f)
{
nmod_poly_t f_d, g, g_1;
mp_limb_t p;
slong deg, i;
if (f->length <= 1)
{
res->num = 0;
return;
}
if (f->length == 2)
{
nmod_poly_factor_insert(res, f, 1);
return;
}
p = nmod_poly_modulus(f);
deg = nmod_poly_degree(f);
/* Step 1, look at f', if it is zero then we are done since f = h(x)^p
for some particular h(x), clearly f(x) = sum a_k x^kp, k <= deg(f) */
nmod_poly_init(g_1, p);
nmod_poly_init(f_d, p);
nmod_poly_init(g, p);
nmod_poly_derivative(f_d, f);
/* Case 1 */
if (nmod_poly_is_zero(f_d))
{
nmod_poly_factor_t new_res;
nmod_poly_t h;
nmod_poly_init(h, p);
for (i = 0; i <= deg / p; i++) /* this will be an integer since f'=0 */
{
nmod_poly_set_coeff_ui(h, i, nmod_poly_get_coeff_ui(f, i * p));
}
/* Now run square-free on h, and return it to the pth power */
nmod_poly_factor_init(new_res);
nmod_poly_factor_squarefree(new_res, h);
nmod_poly_factor_pow(new_res, p);
nmod_poly_factor_concat(res, new_res);
nmod_poly_clear(h);
nmod_poly_factor_clear(new_res);
}
else
{
nmod_poly_t h, z;
nmod_poly_gcd(g, f, f_d);
nmod_poly_div(g_1, f, g);
i = 1;
nmod_poly_init(h, p);
nmod_poly_init(z, p);
/* Case 2 */
while (!nmod_poly_is_one(g_1))
{
nmod_poly_gcd(h, g_1, g);
nmod_poly_div(z, g_1, h);
/* out <- out.z */
if (z->length > 1)
{
nmod_poly_factor_insert(res, z, 1);
nmod_poly_make_monic(res->p + (res->num - 1),
res->p + (res->num - 1));
if (res->num)
res->exp[res->num - 1] *= i;
}
i++;
nmod_poly_set(g_1, h);
nmod_poly_div(g, g, h);
}
nmod_poly_clear(h);
nmod_poly_clear(z);
nmod_poly_make_monic(g, g);
if (!nmod_poly_is_one(g))
{
/* so now we multiply res with square-free(g^1/p) ^ p */
nmod_poly_t g_p; /* g^(1/p) */
nmod_poly_factor_t new_res_2;
nmod_poly_init(g_p, p);
for (i = 0; i <= nmod_poly_degree(g) / p; i++)
nmod_poly_set_coeff_ui(g_p, i, nmod_poly_get_coeff_ui(g, i*p));
nmod_poly_factor_init(new_res_2);
/* square-free(g^(1/p)) */
nmod_poly_factor_squarefree(new_res_2, g_p);
nmod_poly_factor_pow(new_res_2, p);
nmod_poly_factor_concat(res, new_res_2);
nmod_poly_clear(g_p);
nmod_poly_factor_clear(new_res_2);
}
}
nmod_poly_clear(g_1);
nmod_poly_clear(f_d);
nmod_poly_clear(g);
}
int main()
{
flint_rand_t state;
slong nmax, n, bound, count;
mp_limb_t p, pinv, m1, m2;
nmod_poly_t A;
flint_printf("rev....");
fflush(stdout);
flint_randinit(state);
bound = 100000;
p = n_nextprime(UWORD(1) << (FLINT_BITS - 1), 0);
pinv = n_preinvert_limb(p);
nmod_poly_init(A, p);
nmod_poly_set_coeff_ui(A, 1, 1);
nmod_poly_exp_series(A, A, bound);
nmod_poly_shift_right(A, A, 1);
nmod_poly_inv_series(A, A, bound);
m1 = 1;
for (n = 0; n < A->length; n++)
{
A->coeffs[n] = n_mulmod2_preinv(A->coeffs[n], m1, p, pinv);
m1 = n_mulmod2_preinv(m1, n + 1, p, pinv);
}
for (nmax = 0; nmax < bound; nmax = 1.5 * nmax + 2)
{
fmpz_t numer, denom;
bernoulli_rev_t iter;
fmpz_init(numer);
fmpz_init(denom);
nmax += (nmax % 2);
bernoulli_rev_init(iter, nmax);
if (nmax < 8000)
count = 4000;
else
count = 100;
/* flint_printf("nmax = %wd, count = %wd\n", nmax, count); */
for (n = nmax; n >= 0 && count > 0; n -= 2, count--)
{
bernoulli_rev_next(numer, denom, iter);
m1 = fmpz_fdiv_ui(numer, p);
m2 = fmpz_fdiv_ui(denom, p);
m2 = n_invmod(m2, p);
m1 = n_mulmod2_preinv(m1, m2, p, pinv);
m2 = nmod_poly_get_coeff_ui(A, n);
if (m1 != m2)
{
flint_printf("FAIL:\n");
flint_printf("nmax = %wd, n = %wd\n", nmax, n);
flint_printf("m1 = %wu mod %wu\n", m1, p);
flint_printf("m2 = %wu mod %wu\n", m2, p);
abort();
}
}
bernoulli_rev_clear(iter);
fmpz_clear(numer);
fmpz_clear(denom);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, j, result = 1;
fmpz_t t;
flint_rand_t state;
flint_randinit(state);
printf("derivative....");
fflush(stdout);
fmpz_init(t);
/* Check derivative by hand */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_derivative(b, a);
if (a->length <= 1)
result = (b->length == 0);
else
{
for (j = 1; j < a->length; j++)
{
fmpz_set_ui(t, nmod_poly_get_coeff_ui(a, j));
fmpz_mul_ui(t, t, j);
fmpz_mod_ui(t, t, n);
result &= (fmpz_get_ui(t) == nmod_poly_get_coeff_ui(b, j - 1));
}
}
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
}
fmpz_clear(t);
/* Check aliasing */
for (i = 0; i < 10000; i++)
{
nmod_poly_t a, b;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 100));
nmod_poly_derivative(b, a);
nmod_poly_derivative(a, a);
result = nmod_poly_equal(a, b);
if (!result)
{
printf("FAIL:\n");
printf("a->length = %ld, n = %lu\n", a->length, a->mod.n);
nmod_poly_print(a), printf("\n\n");
nmod_poly_print(b), printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void embeddings_isomorphism_2(nmod_poly_t G, mp_srcptr F,
const embeddings_t FP, const embeddings_t FQ, const embeddings_t FR){
nmod_t mod = G->mod;
long m = nmod_poly_degree(FP->P);
long n = nmod_poly_degree(FQ->P);
long np = n + m - 1;
long p = ceil(sqrt(np));
long q = ceil((1.0*np)/p);
long i, j, k;
nmod_poly_t iT, iTm, T, X, tmp;
nmod_poly_struct *TT;
nmod_poly_init(iTm, mod.n);
nmod_poly_init(iT, mod.n);
nmod_poly_init(T, mod.n);
nmod_poly_init(X, mod.n);
nmod_poly_init(tmp, mod.n);
nmod_poly_mat_t MT, MH, MV;
nmod_poly_mat_init(MT, q, n, mod.n);
nmod_poly_mat_init(MH, p, q, mod.n);
nmod_poly_mat_init(MV, p, n, mod.n);
TT = flint_malloc(sizeof(nmod_poly_struct) * (q+1));
for (i = 0; i < q+1; i++)
nmod_poly_init(TT+i, mod.n);
nmod_poly_set_coeff_ui(X, 1, 1);
embeddings_embed(T, X, FQ, FP, FR);
nmod_poly_invmod(iT, T, FR->P);
nmod_poly_powmod_ui_binexp(iTm, iT, m-1, FR->P);
nmod_poly_zero(TT);
nmod_poly_set_coeff_ui(TT, 0, 1);
for (i = 1; i < q+1; i++)
nmod_poly_mulmod(TT+i, TT+(i-1), T, FR->P);
for (i = 0; i < q; i++)
for (j = 0; j < n; j++){
long jm = j*m;
for (k = 0; k < m; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MT, i, j), k, nmod_poly_get_coeff_ui(TT+i, k+jm));
}
for (i = 0; i < p; i++)
for (j = 0; j < q; j++){
long idx = i*q+j;
long lo = FLINT_MAX(0,m-1-idx);
long hi = FLINT_MIN(m,n+m-1-idx);
for (k = lo; k < hi; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MH, i, j), k, F[k*n+k+idx-m+1]);
}
nmod_poly_mat_mul(MV, MH, MT);
nmod_poly_zero(G);
for (i = p-1; i >= 0; i--){
nmod_poly_zero(tmp);
for (j = 0; j < n; j++){
long len = nmod_poly_mat_entry(MV, i, j)->length;
mp_ptr coefs = nmod_poly_mat_entry(MV, i, j)->coeffs;
long jm = j*m;
for (k = 0; k < len; k++)
nmod_poly_set_coeff_ui(tmp, k+jm, n_addmod(nmod_poly_get_coeff_ui(tmp, k+jm), coefs[k], mod.n));
}
nmod_poly_rem(tmp, tmp, FR->P);
nmod_poly_mulmod(G, G, TT+q, FR->P);
nmod_poly_add(G, G, tmp);
}
nmod_poly_mulmod(G, G, iTm, FR->P);
nmod_poly_clear(tmp);
nmod_poly_mat_clear(MT);
nmod_poly_mat_clear(MH);
nmod_poly_mat_clear(MV);
for (i = 0; i < q+1; i++)
nmod_poly_clear(TT+i);
flint_free(TT);
nmod_poly_clear(iTm);
nmod_poly_clear(iT);
nmod_poly_clear(T);
nmod_poly_clear(X);
}
