void fmpz_poly_q_canonicalise(fmpz_poly_q_t rop)
{
fmpz_poly_t gcd;
if (fmpz_poly_is_zero(rop->den))
{
flint_printf("Exception (fmpz_poly_q_canonicalise). Denominator is zero.\n");
abort();
}
if (fmpz_poly_is_one(rop->den))
return;
fmpz_poly_init(gcd);
fmpz_poly_gcd(gcd, rop->num, rop->den);
if (!fmpz_poly_is_unit(gcd))
{
fmpz_poly_div(rop->num, rop->num, gcd);
fmpz_poly_div(rop->den, rop->den, gcd);
}
fmpz_poly_clear(gcd);
if (fmpz_sgn(fmpz_poly_lead(rop->den)) < 0)
{
fmpz_poly_neg(rop->num, rop->num);
fmpz_poly_neg(rop->den, rop->den);
}
}
int _dgsl_rot_mp_call_inlattice_multiplier(fmpz_poly_t rop, const dgsl_rot_mp_t *self, gmp_randstate_t state) {
const long n = self->n;
fmpq_poly_t x;
fmpq_poly_init(x);
fmpq_poly_sample_D1(x, n, self->prec, state);
fmpq_poly_oz_mul(x, self->sigma_sqrt, x, self->n);
fmpq_poly_neg(x, x);;
fmpz_poly_disc_gauss_rounding(rop, x, self->r_f, state);
fmpz_poly_neg(rop, rop);;
fmpq_poly_clear(x);
return 0;
}
int dgsl_rot_mp_call_plus1(fmpz_poly_t rop, const dgsl_rot_mp_t *self, gmp_randstate_t state) {
const long n = self->n;
fmpq_poly_t x;
fmpq_poly_init(x);
fmpq_poly_sample_D1(x, n, self->prec, state);
fmpq_poly_oz_mul(x, self->sigma_sqrt, x, self->n);
fmpq_poly_neg(x, x); // (-x2)
// we sample with centre c = -1/g
fmpq_poly_sub(x, x, self->B_inv); // (c+x2)
fmpz_poly_disc_gauss_rounding(rop, x, self->r_f, state);
fmpz_poly_neg(rop, rop);
fmpz_poly_oz_mul(rop, self->B, rop, self->n);
fmpz_add_ui(rop->coeffs, rop->coeffs, 1);
fmpq_poly_clear(x);
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 < 50; i++)
{
fmpz_poly_t f, g;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_revert_series(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
printf("FAIL (aliasing):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 50; i++)
{
fmpz_poly_t f, g, h;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 10);
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
printf("FAIL (comparison):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
fmpz_poly_print(h), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("revert_series_lagrange_fast....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_revert_series_lagrange_fast(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
flint_printf("FAIL (aliasing):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
flint_printf("FAIL (comparison):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
fmpz_poly_print(h), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
fmpz_poly_mat_inv(fmpz_poly_mat_t Ainv, fmpz_poly_t den,
const fmpz_poly_mat_t A)
{
long n = fmpz_poly_mat_nrows(A);
if (n == 0)
{
fmpz_poly_one(den);
return 1;
}
else if (n == 1)
{
fmpz_poly_set(den, E(A, 0, 0));
fmpz_poly_one(E(Ainv, 0, 0));
return !fmpz_poly_is_zero(den);
}
else if (n == 2)
{
fmpz_poly_mat_det(den, A);
if (fmpz_poly_is_zero(den))
{
return 0;
}
else if (Ainv == A)
{
fmpz_poly_swap(E(A, 0, 0), E(A, 1, 1));
fmpz_poly_neg(E(A, 0, 1), E(A, 0, 1));
fmpz_poly_neg(E(A, 1, 0), E(A, 1, 0));
return 1;
}
else
{
fmpz_poly_set(E(Ainv, 0, 0), E(A, 1, 1));
fmpz_poly_set(E(Ainv, 1, 1), E(A, 0, 0));
fmpz_poly_neg(E(Ainv, 0, 1), E(A, 0, 1));
fmpz_poly_neg(E(Ainv, 1, 0), E(A, 1, 0));
return 1;
}
}
else
{
fmpz_poly_mat_t LU, I;
long * perm;
int result;
perm = _perm_init(n);
fmpz_poly_mat_init_set(LU, A);
result = (fmpz_poly_mat_fflu(LU, den, perm, LU, 1) == n);
if (result)
{
fmpz_poly_mat_init(I, n, n);
fmpz_poly_mat_one(I);
fmpz_poly_mat_solve_fflu_precomp(Ainv, perm, LU, I);
fmpz_poly_mat_clear(I);
}
else
fmpz_poly_zero(den);
if (_perm_parity(perm, n))
{
fmpz_poly_mat_neg(Ainv, Ainv);
fmpz_poly_neg(den, den);
}
_perm_clear(perm);
fmpz_poly_mat_clear(LU);
return result;
}
}
int
fmpz_poly_gcd_heuristic(fmpz_poly_t res,
const fmpz_poly_t poly1, const fmpz_poly_t poly2)
{
const long len1 = poly1->length;
const long len2 = poly2->length;
long rlen;
int done = 0;
if (len1 == 0)
{
if (len2 == 0)
fmpz_poly_zero(res);
else
{
if (fmpz_sgn(poly2->coeffs + (len2 - 1)) > 0)
fmpz_poly_set(res, poly2);
else
fmpz_poly_neg(res, poly2);
}
return 1;
}
else
{
if (len2 == 0)
{
if (fmpz_sgn(poly1->coeffs + (len1 - 1)) > 0)
fmpz_poly_set(res, poly1);
else
fmpz_poly_neg(res, poly1);
return 1;
}
}
rlen = FLINT_MIN(len1, len2);
if (res == poly1 || res == poly2)
{
fmpz_poly_t temp;
fmpz_poly_init2(temp, rlen);
if (len1 >= len2)
done = _fmpz_poly_gcd_heuristic(temp->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2);
else
done = _fmpz_poly_gcd_heuristic(temp->coeffs, poly2->coeffs, len2,
poly1->coeffs, len1);
fmpz_poly_swap(temp, res);
fmpz_poly_clear(temp);
}
else
{
fmpz_poly_fit_length(res, rlen);
if (len1 >= len2)
done = _fmpz_poly_gcd_heuristic(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2);
else
done = _fmpz_poly_gcd_heuristic(res->coeffs, poly2->coeffs, len2,
poly1->coeffs, len1);
}
if (done)
{
_fmpz_poly_set_length(res, rlen);
_fmpz_poly_normalise(res);
}
return done;
}
long _fmpz_poly_hensel_start_lift(fmpz_poly_factor_t lifted_fac, long *link,
fmpz_poly_t *v, fmpz_poly_t *w, const fmpz_poly_t f,
const nmod_poly_factor_t local_fac, long N)
{
const long r = local_fac->num;
long i, preve;
fmpz_t p, P;
fmpz_poly_t monic_f;
fmpz_init(p);
fmpz_init(P);
fmpz_poly_init(monic_f);
fmpz_set_ui(p, (local_fac->p + 0)->mod.n);
fmpz_pow_ui(P, p, N);
if (fmpz_is_one(fmpz_poly_lead(f)))
{
fmpz_poly_set(monic_f, f);
}
else if (fmpz_cmp_si(fmpz_poly_lead(f), -1) == 0)
{
fmpz_poly_neg(monic_f, f);
}
else
{
fmpz_t t;
fmpz_init(t);
fmpz_mod(t, fmpz_poly_lead(f), P);
if (fmpz_invmod(t, t, P) == 0)
{
printf("Exception in fmpz_poly_start_hensel_lift.\n");
abort();
}
fmpz_poly_scalar_mul_fmpz(monic_f, f, t);
fmpz_poly_scalar_mod_fmpz(monic_f, monic_f, P);
fmpz_clear(t);
}
fmpz_poly_hensel_build_tree(link, v, w, local_fac);
{
long *e, n = FLINT_CLOG2(N) + 1;
e = flint_malloc(n * sizeof(long));
for (e[i = 0] = N; e[i] > 1; i++)
e[i + 1] = (e[i] + 1) / 2;
for (i--; i > 0; i--)
{
fmpz_poly_hensel_lift_tree(link, v, w, monic_f, r,
p, e[i+1], e[i], 1);
}
if (N > 1)
{
fmpz_poly_hensel_lift_tree(link, v, w, monic_f, r,
p, e[i+1], e[i], 0);
}
preve = e[i+1];
flint_free(e);
}
/*
Now everything is lifted to p^N, we just need to
insert the factors into their correct places in lifted_fac.
*/
fmpz_poly_factor_fit_length(lifted_fac, r);
for (i = 0; i < 2*r - 2; i++)
{
if (link[i] < 0)
{
fmpz_poly_scalar_smod_fmpz(lifted_fac->p + (- link[i] - 1), v[i], P);
lifted_fac->exp[- link[i] - 1] = 1L;
}
}
lifted_fac->num = r;
fmpz_clear(p);
fmpz_clear(P);
fmpz_poly_clear(monic_f);
return preve;
}
int
main(void)
{
flint_rand_t state;
long i;
printf("inv....");
fflush(stdout);
flint_randinit(state);
/* Test aliasing */
for (i = 0; i < 400; i++)
{
fmpz_poly_mat_t A, Ainv;
fmpz_poly_t den1, den2;
long n, bits, deg;
float density;
int ns1, ns2;
int result;
n = n_randint(state, 8);
deg = 1 + n_randint(state, 5);
bits = 1 + n_randint(state, 100);
density = n_randint(state, 100) * 0.01;
fmpz_poly_mat_init(A, n, n);
fmpz_poly_mat_init(Ainv, n, n);
fmpz_poly_init(den1);
fmpz_poly_init(den2);
fmpz_poly_mat_randtest_sparse(A, state, deg, bits, density);
ns1 = fmpz_poly_mat_inv(Ainv, den1, A);
ns2 = fmpz_poly_mat_inv(A, den2, A);
result = ns1 == ns2;
if (result && ns1 != 0)
{
result = fmpz_poly_equal(den1, den2) &&
fmpz_poly_mat_equal(A, Ainv);
}
if (!result)
{
printf("FAIL (aliasing)!\n");
fmpz_poly_mat_print(A, "x"); printf("\n");
fmpz_poly_mat_print(Ainv, "x"); printf("\n");
abort();
}
fmpz_poly_mat_clear(A);
fmpz_poly_mat_clear(Ainv);
fmpz_poly_clear(den1);
fmpz_poly_clear(den2);
}
/* Check A^(-1) = A = 1 */
for (i = 0; i < 1000; i++)
{
fmpz_poly_mat_t A, Ainv, B, Iden;
fmpz_poly_t den, det;
long n, bits, deg;
float density;
int nonsingular;
n = n_randint(state, 10);
deg = 1 + n_randint(state, 5);
bits = 1 + n_randint(state, 100);
density = n_randint(state, 100) * 0.01;
fmpz_poly_mat_init(A, n, n);
fmpz_poly_mat_init(Ainv, n, n);
fmpz_poly_mat_init(B, n, n);
fmpz_poly_mat_init(Iden, n, n);
fmpz_poly_init(den);
fmpz_poly_init(det);
fmpz_poly_mat_randtest_sparse(A, state, deg, bits, density);
nonsingular = fmpz_poly_mat_inv(Ainv, den, A);
fmpz_poly_mat_det_interpolate(det, A);
if (n == 0)
{
if (nonsingular == 0 || !fmpz_poly_is_one(den))
{
printf("FAIL: expected empty matrix to pass\n");
abort();
}
}
else
{
if (!fmpz_poly_equal(den, det))
{
fmpz_poly_neg(det, det);
printf("FAIL: den != det(A)\n");
abort();
}
fmpz_poly_mat_mul(B, Ainv, A);
fmpz_poly_mat_one(Iden);
fmpz_poly_mat_scalar_mul_fmpz_poly(Iden, Iden, den);
if (!fmpz_poly_mat_equal(B, Iden))
{
printf("FAIL:\n");
printf("A:\n");
fmpz_poly_mat_print(A, "x");
printf("Ainv:\n");
fmpz_poly_mat_print(Ainv, "x");
printf("B:\n");
fmpz_poly_mat_print(B, "x");
printf("den:\n");
fmpz_poly_print_pretty(den, "x");
abort();
}
}
fmpz_poly_clear(den);
fmpz_poly_clear(det);
fmpz_poly_mat_clear(A);
fmpz_poly_mat_clear(Ainv);
fmpz_poly_mat_clear(B);
fmpz_poly_mat_clear(Iden);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
