int main()
{
fmpq_poly_t P, Q;
mpz_t t;
slong k, n;
FLINT_TEST_INIT(state);
flint_printf("bernoulli_polynomial....");
fflush(stdout);
for (n = 0; n <= 100; n++)
{
fmpq_poly_init(P);
fmpq_poly_init(Q);
mpz_init(t);
for (k = 0; k <= n; k++)
{
arith_bernoulli_polynomial(P, k);
flint_mpz_bin_uiui(t, n+1, k);
fmpq_poly_scalar_mul_mpz(P, P, t);
fmpq_poly_add(Q, Q, P);
}
fmpq_poly_scalar_div_ui(Q, Q, n+1);
mpz_clear(t);
fmpq_poly_zero(P);
fmpq_poly_set_coeff_ui(P, n, UWORD(1));
if (!fmpq_poly_equal(P, Q))
{
flint_printf("ERROR: sum up to n = %wd did not add to x^n\n", n);
flint_printf("Sum: ");
fmpq_poly_print_pretty(Q, "x");
flint_printf("\nExpected: ");
fmpq_poly_print_pretty(P, "x");
flint_printf("\n");
abort();
}
fmpq_poly_clear(P);
fmpq_poly_clear(Q);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
fmpq_poly_t Pn, Pn1, Pn2, R;
long n;
printf("legendre_polynomial....");
fflush(stdout);
fmpq_poly_init(Pn);
fmpq_poly_init(Pn1);
fmpq_poly_init(Pn2);
fmpq_poly_init(R);
fmpq_poly_set_ui(Pn, 1UL);
fmpq_poly_set_coeff_ui(Pn1, 1, 1UL);
for (n = 0; n <= 500; n++)
{
legendre_polynomial(R, n);
if (!fmpq_poly_equal(Pn, R))
{
printf("FAIL: n = %ld\n", n);
printf("Direct: "); fmpq_poly_print_pretty(R, "x"); printf("\n");
printf("Recur.: "); fmpq_poly_print_pretty(Pn, "x"); printf("\n");
abort();
}
fmpq_poly_shift_left(Pn2, Pn1, 1);
fmpq_poly_scalar_mul_ui(Pn2, Pn2, 2*n + 3);
fmpq_poly_scalar_mul_si(Pn, Pn, -(n+1));
fmpq_poly_add(Pn2, Pn2, Pn);
fmpq_poly_scalar_div_ui(Pn2, Pn2, n+2);
fmpq_poly_swap(Pn, Pn1);
fmpq_poly_swap(Pn1, Pn2);
}
fmpq_poly_clear(Pn);
fmpq_poly_clear(Pn1);
fmpq_poly_clear(Pn2);
fmpq_poly_clear(R);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int dgsl_rot_mp_call_recenter_fmpq_poly(fmpz_poly_t rop, const dgsl_rot_mp_t *self, const fmpq_poly_t c, gmp_randstate_t state) {
fmpq_poly_t x;
fmpq_poly_init(x);
fmpq_poly_sample_D1(x, self->n, self->prec, state);
fmpq_poly_oz_mul(x, self->sigma_sqrt, x, self->n);
fmpq_poly_neg(x, x);
// we sample with centre c/g
fmpq_poly_t t; fmpq_poly_init(t);
fmpq_poly_oz_mul(t, c, self->B_inv, self->n);
fmpq_poly_add(x, t, x); // (c+x2)
fmpq_poly_clear(t);
fmpz_poly_disc_gauss_rounding(rop, x, self->r_f, state);
fmpz_poly_oz_mul(rop, self->B, rop, self->n);
fmpq_poly_clear(x);
return 0;
}
int
main(void)
{
int i, result;
ulong cflags = UWORD(0);
FLINT_TEST_INIT(state);
flint_printf("scalar_div_fmpq....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b;
fmpq_t z;
fmpq_init(z);
fmpq_randtest_not_zero(z, state, 100);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpq(b, a, z);
fmpq_poly_scalar_div_fmpq(a, a, z);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(b) ? 0 : 2;
result = (fmpq_poly_equal(a, b) && !cflags);
if (!result)
{
flint_printf("FAIL (aliasing):\n\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpq_print(z), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_clear(z);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Check that (a / n1) / n2 == a / (n1 * n2) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, lhs, rhs;
fmpq_t z1, z2, z;
fmpq_init(z1);
fmpq_init(z2);
fmpq_init(z);
fmpq_randtest_not_zero(z1, state, 100);
fmpq_randtest_not_zero(z2, state, 100);
fmpq_mul(z, z1, z2);
fmpq_poly_init(a);
fmpq_poly_init(lhs);
fmpq_poly_init(rhs);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpq(lhs, a, z1);
fmpq_poly_scalar_div_fmpq(lhs, lhs, z2);
fmpq_poly_scalar_div_fmpq(rhs, a, z);
cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2;
result = (fmpq_poly_equal(lhs, rhs) && !cflags);
if (!result)
{
flint_printf("FAIL (a / n1 / n2):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_print(z1), flint_printf("\n\n");
fmpq_print(z2), flint_printf("\n\n");
fmpq_print(z), flint_printf("\n\n");
fmpq_poly_debug(lhs), flint_printf("\n\n");
fmpq_poly_debug(rhs), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_clear(z1);
fmpq_clear(z2);
fmpq_clear(z);
fmpq_poly_clear(a);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
/* Check that (a + b) / n == a/n + b/n */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, lhs, rhs;
fmpq_t z;
fmpq_init(z);
fmpq_randtest_not_zero(z, state, 100);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(lhs);
fmpq_poly_init(rhs);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpq(lhs, a, z);
fmpq_poly_scalar_div_fmpq(rhs, b, z);
fmpq_poly_add(rhs, lhs, rhs);
fmpq_poly_add(lhs, a, b);
fmpq_poly_scalar_div_fmpq(lhs, lhs, z);
cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2;
result = (fmpq_poly_equal(lhs, rhs) && !cflags);
if (!result)
{
flint_printf("FAIL ((a + b) / n):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpq_print(z), flint_printf("\n\n");
fmpq_poly_debug(lhs), flint_printf("\n\n");
fmpq_poly_debug(rhs), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_clear(z);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
ulong cflags = UWORD(0);
FLINT_TEST_INIT(state);
flint_printf("add....");
fflush(stdout);
/* Check aliasing of a and c */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, c;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_add(c, a, b);
fmpq_poly_add(a, a, b);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(c) ? 0 : 2;
result = (fmpq_poly_equal(a, c) && !cflags);
if (!result)
{
flint_printf("FAIL:\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpq_poly_debug(c), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
}
/* Check aliasing of b and c */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, c;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_add(c, a, b);
fmpq_poly_add(b, a, b);
cflags |= fmpq_poly_is_canonical(b) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(c) ? 0 : 2;
result = (fmpq_poly_equal(b, c) && !cflags);
if (!result)
{
flint_printf("FAIL:\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpq_poly_debug(c), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
ulong cflags = UWORD(0);
FLINT_TEST_INIT(state);
flint_printf("compose....");
fflush(stdout);
/* Check aliasing of the first argument */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpq_poly_t f, g, h;
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_init(h);
fmpq_poly_randtest(g, state, n_randint(state, 50), 100);
fmpq_poly_randtest(h, state, n_randint(state, 20), 50);
fmpq_poly_compose(f, g, h);
fmpq_poly_compose(g, g, h);
cflags |= fmpq_poly_is_canonical(f) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(g) ? 0 : 2;
result = (fmpq_poly_equal(f, g) && !cflags);
if (!result)
{
flint_printf("FAIL (aliasing 1):\n");
fmpq_poly_debug(f), flint_printf("\n\n");
fmpq_poly_debug(g), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
}
/* Check aliasing of the second argument */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpq_poly_t f, g, h;
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_init(h);
fmpq_poly_randtest(g, state, n_randint(state, 50), 100);
fmpq_poly_randtest(h, state, n_randint(state, 20), 50);
fmpq_poly_compose(f, g, h);
fmpq_poly_compose(h, g, h);
cflags |= fmpq_poly_is_canonical(f) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(h) ? 0 : 2;
result = (fmpq_poly_equal(f, h) && !cflags);
if (!result)
{
flint_printf("FAIL (aliasing 2):\n");
fmpq_poly_debug(f), flint_printf("\n\n");
fmpq_poly_debug(h), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
}
/* Compare with the naive method for g(h(t)) */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpq_poly_t f, g, h, s, t, u;
mpq_t c;
slong k;
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_init(h);
fmpq_poly_init(s);
fmpq_poly_init(t);
fmpq_poly_init(u);
mpq_init(c);
fmpq_poly_randtest(g, state, n_randint(state, 20), 65);
fmpq_poly_randtest(h, state, n_randint(state, 20), 65);
fmpq_poly_zero(s);
fmpq_poly_set_ui(t, UWORD(1));
for (k = WORD(0); k < g->length; k++)
{
fmpq_poly_get_coeff_mpq(c, g, k);
fmpq_poly_scalar_mul_mpq(u, t, c);
fmpq_poly_add(s, s, u);
fmpq_poly_mul(t, t, h);
}
fmpq_poly_compose(f, g, h);
result = (fmpq_poly_equal(f, s));
if (!result)
{
flint_printf("FAIL (compare with naive):\n");
flint_printf("g = "), fmpq_poly_debug(g), flint_printf("\n\n");
flint_printf("h = "), fmpq_poly_debug(h), flint_printf("\n\n");
flint_printf("f = "), fmpq_poly_debug(f), flint_printf("\n\n");
flint_printf("s = "), fmpq_poly_debug(s), flint_printf("\n\n");
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
fmpq_poly_clear(s);
fmpq_poly_clear(t);
fmpq_poly_clear(u);
mpq_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int cflags = 0, i, result;
flint_rand_t state;
printf("xgcd....");
fflush(stdout);
flint_randinit(state);
/* Generic case, where a and b are coprime *******************************/
/* Verify d == s a + t b */
for (i = 0; i < 100; i++)
{
fmpq_poly_t a, b, d, e, f, s, t;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(d);
fmpq_poly_init(e);
fmpq_poly_init(f);
fmpq_poly_init(s);
fmpq_poly_init(t);
fmpq_poly_randtest(a, state, n_randint(state, 60), 80);
fmpq_poly_randtest(b, state, n_randint(state, 60), 80);
fmpq_poly_xgcd(d, s, t, a, b);
fmpq_poly_mul(e, s, a);
fmpq_poly_mul(f, t, b);
fmpq_poly_add(e, e, f);
cflags |= fmpq_poly_is_canonical(d) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(s) ? 0 : 2;
cflags |= fmpq_poly_is_canonical(t) ? 0 : 4;
result = (fmpq_poly_equal(d, e) && !cflags);
if (!result)
{
printf("FAIL (correctness #1):\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(d), printf("\n\n");
fmpq_poly_debug(s), printf("\n\n");
fmpq_poly_debug(t), printf("\n\n");
printf("cflags = %d\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(d);
fmpq_poly_clear(e);
fmpq_poly_clear(f);
fmpq_poly_clear(s);
fmpq_poly_clear(t);
}
/* Verify consistency with GCD */
for (i = 0; i < 100; i++)
{
fmpq_poly_t a, b, d, s, t;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(d);
fmpq_poly_init(s);
fmpq_poly_init(t);
fmpq_poly_randtest(a, state, n_randint(state, 60), 80);
fmpq_poly_randtest(b, state, n_randint(state, 60), 80);
fmpq_poly_xgcd(d, s, t, a, b);
fmpq_poly_gcd(a, a, b);
cflags |= fmpq_poly_is_canonical(d) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(s) ? 0 : 2;
cflags |= fmpq_poly_is_canonical(t) ? 0 : 4;
result = (fmpq_poly_equal(d, a) && !cflags);
if (!result)
{
printf("FAIL (GCD #1):\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(d), printf("\n\n");
fmpq_poly_debug(s), printf("\n\n");
fmpq_poly_debug(t), printf("\n\n");
printf("cflags = %d\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(d);
fmpq_poly_clear(s);
fmpq_poly_clear(t);
}
/* Generic case when a, b are most likely co-prime ***********************/
/* Verify d == s a + t b */
for (i = 0; i < 100; i++)
{
fmpq_poly_t a, b, d, s, t, z;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(d);
fmpq_poly_init(s);
fmpq_poly_init(t);
fmpq_poly_init(z);
fmpq_poly_randtest(a, state, n_randint(state, 60), 80);
fmpq_poly_randtest(b, state, n_randint(state, 60), 80);
fmpq_poly_randtest(z, state, n_randint(state, 20), 20);
fmpq_poly_mul(a, a, z);
fmpq_poly_mul(b, b, z);
fmpq_poly_xgcd(d, s, t, a, b);
fmpq_poly_mul(a, s, a);
fmpq_poly_mul(b, t, b);
fmpq_poly_add(a, a, b);
cflags |= fmpq_poly_is_canonical(d) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(s) ? 0 : 2;
cflags |= fmpq_poly_is_canonical(t) ? 0 : 4;
result = (fmpq_poly_equal(d, a) && !cflags);
if (!result)
{
printf("FAIL (correctness #2):\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(d), printf("\n\n");
fmpq_poly_debug(s), printf("\n\n");
fmpq_poly_debug(t), printf("\n\n");
printf("cflags = %d\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(d);
fmpq_poly_clear(s);
fmpq_poly_clear(t);
fmpq_poly_clear(z);
}
/* Verify consistency with GCD */
for (i = 0; i < 100; i++)
{
fmpq_poly_t a, b, d, s, t, z;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(d);
fmpq_poly_init(s);
fmpq_poly_init(t);
fmpq_poly_init(z);
fmpq_poly_randtest(a, state, n_randint(state, 60), 80);
fmpq_poly_randtest(b, state, n_randint(state, 60), 80);
fmpq_poly_randtest(z, state, n_randint(state, 20), 20);
fmpq_poly_mul(a, a, z);
fmpq_poly_mul(b, b, z);
fmpq_poly_xgcd(d, s, t, a, b);
fmpq_poly_gcd(a, a, b);
cflags |= fmpq_poly_is_canonical(d) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(s) ? 0 : 2;
cflags |= fmpq_poly_is_canonical(t) ? 0 : 4;
result = (fmpq_poly_equal(d, a) && !cflags);
if (!result)
{
printf("FAIL (GCD #2):\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(d), printf("\n\n");
fmpq_poly_debug(s), printf("\n\n");
fmpq_poly_debug(t), printf("\n\n");
printf("cflags = %d\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(d);
fmpq_poly_clear(s);
fmpq_poly_clear(t);
fmpq_poly_clear(z);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
ulong cflags = UWORD(0);
FLINT_TEST_INIT(state);
flint_printf("scalar_div_fmpz....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b;
fmpz_t n;
fmpz_init(n);
fmpz_randtest_not_zero(n, state, 200);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(b, a, n);
fmpq_poly_scalar_div_fmpz(a, a, n);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(b) ? 0 : 2;
result = (fmpq_poly_equal(a, b) && !cflags);
if (!result)
{
flint_printf("FAIL (aliasing):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
fmpz_print(n);
abort();
}
fmpz_clear(n);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Compare with fmpq_poly_scalar_mul_si */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, c;
fmpz_t n1;
slong n;
n = z_randtest_not_zero(state);
fmpz_init(n1);
fmpz_set_si(n1, n);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(b, a, n1);
fmpq_poly_scalar_div_si(c, a, n);
cflags |= fmpq_poly_is_canonical(b) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(c) ? 0 : 2;
result = (fmpq_poly_equal(b, c) && !cflags);
if (!result)
{
flint_printf("FAIL (comparison with _si):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpz_print(n1), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpq_poly_debug(c), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpz_clear(n1);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
}
/* Check that (a / n1) / n2 == a / (n1 * n2) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, lhs, rhs;
fmpz_t n1, n2, n;
fmpz_init(n1);
fmpz_init(n2);
fmpz_init(n);
fmpz_randtest_not_zero(n1, state, 100);
fmpz_randtest_not_zero(n2, state, 100);
fmpz_mul(n, n1, n2);
fmpq_poly_init(a);
fmpq_poly_init(lhs);
fmpq_poly_init(rhs);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(lhs, a, n1);
fmpq_poly_scalar_div_fmpz(lhs, lhs, n2);
fmpq_poly_scalar_div_fmpz(rhs, a, n);
cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2;
result = (fmpq_poly_equal(lhs, rhs) && !cflags);
if (!result)
{
flint_printf("FAIL (a / n1 / n2):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpz_print(n1), flint_printf("\n\n");
fmpz_print(n2), flint_printf("\n\n");
fmpz_print(n), flint_printf("\n\n");
fmpq_poly_debug(lhs), flint_printf("\n\n");
fmpq_poly_debug(rhs), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpz_clear(n1);
fmpz_clear(n2);
fmpz_clear(n);
fmpq_poly_clear(a);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
/* Check that (a + b) / n == a/n + b/n */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, lhs, rhs;
fmpz_t n;
fmpz_init(n);
fmpz_randtest_not_zero(n, state, 100);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(lhs);
fmpq_poly_init(rhs);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(lhs, a, n);
fmpq_poly_scalar_div_fmpz(rhs, b, n);
fmpq_poly_add(rhs, lhs, rhs);
fmpq_poly_add(lhs, a, b);
fmpq_poly_scalar_div_fmpz(lhs, lhs, n);
cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2;
result = (fmpq_poly_equal(lhs, rhs) && !cflags);
if (!result)
{
flint_printf("FAIL ((a + b) / n):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpz_print(n), flint_printf("\n\n");
fmpq_poly_debug(lhs), flint_printf("\n\n");
fmpq_poly_debug(rhs), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpz_clear(n);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("add....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpq_poly */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong qbits1, qbits2, rbits1, rbits2, rbits3, trunc;
fmpq_poly_t A, B, C;
acb_poly_t a, b, c, d;
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
trunc = n_randint(state, 10);
fmpq_poly_init(A);
fmpq_poly_init(B);
fmpq_poly_init(C);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
fmpq_poly_randtest(A, state, 1 + n_randint(state, 10), qbits1);
fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2);
fmpq_poly_add(C, A, B);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_set_fmpq_poly(b, B, rbits2);
acb_poly_add(c, a, b, rbits3);
if (!acb_poly_contains_fmpq_poly(c, C))
{
flint_printf("FAIL\n\n");
flint_printf("bits3 = %wd\n", rbits3);
flint_printf("trunc = %wd\n", trunc);
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n");
flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n");
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
abort();
}
acb_poly_set(d, a);
acb_poly_add(d, d, b, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
abort();
}
acb_poly_set(d, b);
acb_poly_add(d, a, d, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\n\n");
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
fmpq_poly_clear(C);
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("add....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
slong qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t A, B, C;
arb_poly_t a, b, c;
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
fmpq_poly_init(A);
fmpq_poly_init(B);
fmpq_poly_init(C);
arb_poly_init(a);
arb_poly_init(b);
arb_poly_init(c);
fmpq_poly_randtest(A, state, 1 + n_randint(state, 10), qbits1);
fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2);
fmpq_poly_add(C, A, B);
arb_poly_set_fmpq_poly(a, A, rbits1);
arb_poly_set_fmpq_poly(b, B, rbits2);
arb_poly_add(c, a, b, rbits3);
if (!arb_poly_contains_fmpq_poly(c, C))
{
flint_printf("FAIL\n\n");
flint_printf("bits3 = %wd\n", rbits3);
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n");
flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n");
flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n");
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
fmpq_poly_clear(C);
arb_poly_clear(a);
arb_poly_clear(b);
arb_poly_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int fmpq_poly_oz_sqrt_approx_babylonian(fmpq_poly_t f_sqrt, const fmpq_poly_t f, const long n, const mpfr_prec_t prec, const mpfr_prec_t bound, oz_flag_t flags, const fmpq_poly_t init) {
fmpq_poly_t y; fmpq_poly_init(y);
fmpq_poly_t y_next; fmpq_poly_init(y_next);
mpfr_t norm; mpfr_init2(norm, prec);
mpfr_t prev_norm; mpfr_init2(prev_norm, prec);
if (init) {
fmpq_poly_set(y, init);
} else {
fmpq_poly_set(y, f);
}
mpfr_t log_f;
mpfr_init2(log_f, prec);
uint64_t t = oz_walltime(0);
int r = 0;
for(long k=0; ; k++) {
_fmpq_poly_oz_invert_approx(y_next, y, n, prec);
fmpq_poly_oz_mul(y_next, f, y_next, n);
fmpq_poly_add(y_next, y_next, y);
fmpq_poly_scalar_div_si(y_next, y_next, 2);
fmpq_poly_set(y, y_next);
r = _fmpq_poly_oz_sqrt_approx_break(norm, y, f, n, bound, prec);
if(flags & OZ_VERBOSE) {
mpfr_log2(log_f, norm, MPFR_RNDN);
mpfr_fprintf(stderr, "Computing sqrt(Σ):: k: %4d, Δ=|sqrt(Σ)^2-Σ|: %7.2Rf", k, log_f);
fprintf(stderr, " <? %4ld, ", -bound);
fprintf(stderr, "t: %8.2fs\n", oz_seconds(oz_walltime(t)));
fflush(0);
}
if(r) {
r = 0;
break;
}
if (k>0 && mpfr_cmp_ui_2exp(norm, 1, bound) >= 0) {
/* something went really wrong */
r = -1;
break;
}
mpfr_div_ui(prev_norm, prev_norm, 2, MPFR_RNDN);
if (k>0 && mpfr_cmp(norm, prev_norm) >= 0) {
/* we don't converge any more */
r = 1;
break;
}
mpfr_set(prev_norm, norm, MPFR_RNDN);
}
mpfr_clear(log_f);
fmpq_poly_set(f_sqrt, y);
mpfr_clear(norm);
mpfr_clear(prev_norm);
fmpq_poly_clear(y_next);
fmpq_poly_clear(y);
return r;
}
int fmpq_poly_oz_sqrt_approx_pade(fmpq_poly_t f_sqrt, const fmpq_poly_t f, const long n, const int p, const mpfr_prec_t prec, const mpfr_prec_t bound, oz_flag_t flags, const fmpq_poly_t init) {
fmpq_poly_t y; fmpq_poly_init(y);
fmpq_poly_t y_next; fmpq_poly_init(y_next);
fmpq_poly_t z; fmpq_poly_init(z);
fmpq_poly_t z_next; fmpq_poly_init(z_next);
mpfr_t norm; mpfr_init2(norm, prec);
mpfr_t prev_norm; mpfr_init2(prev_norm, prec);
mpfr_t log_f; mpfr_init2(log_f, prec);
if (init) {
// z = y/x
fmpq_poly_set(y, init);
_fmpq_poly_oz_invert_approx(z, f, n, prec);
fmpq_poly_oz_mul(z, z, y, n);
} else {
fmpq_poly_set(y, f);
fmpq_poly_set_coeff_si(z, 0, 1);
}
fmpq_t *xi = (fmpq_t*)calloc(p, sizeof(fmpq_t));
fmpq_t *a2 = (fmpq_t*)calloc(p, sizeof(fmpq_t));
fmpq_t *c = (fmpq_t*)calloc(p, sizeof(fmpq_t));
fmpq_poly_t *t_ = (fmpq_poly_t*)calloc(p, sizeof(fmpq_poly_t));
fmpq_poly_t *s_ = (fmpq_poly_t*)calloc(p, sizeof(fmpq_poly_t));
mpfr_t pi; mpfr_init2(pi, 4*prec);
mpfr_const_pi(pi, MPFR_RNDN);
#pragma omp parallel for
for(int i=0; i<p; i++) {
mpfr_t xi_r; mpfr_init2(xi_r, 4*prec);
mpfr_t a2_r; mpfr_init2(a2_r, 4*prec);
/* ζ_i = 1/2 * (1 + cos( (2·i -1)·π/(2·p) )) */
mpfr_set_si(xi_r, 2*i+1, MPFR_RNDN);
mpfr_mul(xi_r, xi_r, pi, MPFR_RNDN);
mpfr_div_si(xi_r, xi_r, 2*p, MPFR_RNDN);
mpfr_cos(xi_r, xi_r, MPFR_RNDN);
mpfr_add_si(xi_r, xi_r, 1, MPFR_RNDN);
mpfr_div_si(xi_r, xi_r, 2, MPFR_RNDN);
/* α_i^2 = 1/ζ_i -1 */
mpfr_set_si(a2_r, 1, MPFR_RNDN);
mpfr_div(a2_r, a2_r, xi_r, MPFR_RNDN);
mpfr_sub_si(a2_r, a2_r, 1, MPFR_RNDN);
fmpq_init(xi[i]);
fmpq_init(a2[i]);
fmpq_set_mpfr(xi[i], xi_r, MPFR_RNDN);
fmpq_set_mpfr(a2[i], a2_r, MPFR_RNDN);
fmpq_init(c[i]);
fmpq_poly_init(t_[i]);
fmpq_poly_init(s_[i]);
mpfr_clear(xi_r);
mpfr_clear(a2_r);
}
mpfr_clear(pi);
uint64_t t = oz_walltime(0);
int r = 0;
int cont = 1;
for(long k=0; cont; k++) {
if (k == 0 || mpfr_cmp_ui(prev_norm, 1) > 0)
_fmpq_poly_oz_sqrt_approx_scale(y, z, n, prec);
/* T = sum([1/xi[i] * ~(Z*Y + a2[i]) for i in range(p)]) */
#pragma omp parallel for
for(int i=0; i<p; i++) {
fmpq_poly_oz_mul(t_[i], z, y, n);
fmpq_poly_get_coeff_fmpq(c[i], t_[i], 0);
fmpq_add(c[i], c[i], a2[i]);
fmpq_poly_set_coeff_fmpq(t_[i], 0, c[i]);
fmpq_poly_scalar_mul_fmpq(t_[i], t_[i], xi[i]);
_fmpq_poly_oz_invert_approx(s_[i], t_[i], n, prec);
}
for(int i=1; i<p; i++)
fmpq_poly_add(s_[0], s_[0], s_[i]);
#pragma omp parallel sections
{
#pragma omp section
{
fmpq_poly_oz_mul(y_next, y, s_[0], n);
fmpq_poly_scalar_div_si(y_next, y_next, p);
fmpq_poly_set(y, y_next);
}
#pragma omp section
{
fmpq_poly_oz_mul(z_next, z, s_[0], n);
fmpq_poly_scalar_div_si(z_next, z_next, p);
fmpq_poly_set(z, z_next);
}
}
cont = !_fmpq_poly_oz_sqrt_approx_break(norm, y, f, n, bound, prec);
if(flags & OZ_VERBOSE) {
mpfr_log2(log_f, norm, MPFR_RNDN);
mpfr_fprintf(stderr, "Computing sqrt(Σ):: k: %4d, Δ=|sqrt(Σ)^2-Σ|: %7.2Rf", k, log_f);
fprintf(stderr, " <? %4ld, ", -bound);
fprintf(stderr, "t: %8.2fs\n", oz_seconds(oz_walltime(t)));
fflush(0);
}
if (cont) {
if (k>0 && mpfr_cmp_ui_2exp(norm, 1, bound) >= 0) {
/* something went really wrong */
r = -1;
break;
}
if (k>0 && mpfr_cmp(norm, prev_norm) >= 0) {
/* we don't converge any more */
r = 1;
break;
}
mpfr_set(prev_norm, norm, MPFR_RNDN);
}
}
for(int i=0; i<p; i++) {
fmpq_clear(xi[i]);
fmpq_clear(a2[i]);
fmpq_clear(c[i]);
fmpq_poly_clear(t_[i]);
fmpq_poly_clear(s_[i]);
}
free(xi);
free(a2);
free(c);
free(t_);
free(s_);
mpfr_clear(log_f);
fmpq_poly_set(f_sqrt, y);
mpfr_clear(norm);
mpfr_clear(prev_norm);
fmpq_poly_clear(y_next);
fmpq_poly_clear(y);
fmpq_poly_clear(z_next);
fmpq_poly_clear(z);
return r;
}
var AddPolyQ(const Tuple& x,const Tuple& y){
fmpq_poly_t res;
fmpq_poly_init(res);
fmpq_poly_add(res,to_fmpq_poly(x),to_fmpq_poly(y));
return from_fmpq_poly(res);
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("evaluate_fmpz....");
fflush(stdout);
/* Check that (f+g)(a) = f(a) + g(a) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a;
fmpq_poly_t f, g, h;
fmpq_t x, y;
fmpq_init(x);
fmpq_init(y);
fmpz_init(a);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_init(h);
fmpq_poly_randtest(f, state, n_randint(state, 100), 200);
fmpq_poly_randtest(g, state, n_randint(state, 100), 200);
fmpz_randtest(a, state, n_randint(state, 100));
fmpq_poly_evaluate_fmpz(x, f, a);
fmpq_poly_evaluate_fmpz(y, g, a);
fmpq_add(x, x, y);
fmpq_poly_add(h, f, g);
fmpq_poly_evaluate_fmpz(y, h, a);
result = (fmpq_equal(x, y));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("f = "), fmpq_poly_debug(f), flint_printf("\n");
flint_printf("g = "), fmpq_poly_debug(g), flint_printf("\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n");
flint_printf("f(a) + g(a) = "), fmpq_print(x), flint_printf("\n\n");
flint_printf("(f + g)(a) = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(a);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
}
/* Check that (f*g)(a) = f(a) * g(a) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a;
fmpq_poly_t f, g;
fmpq_t x, y;
fmpq_init(x);
fmpq_init(y);
fmpz_init(a);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_randtest(f, state, n_randint(state, 100), 200);
fmpq_poly_randtest(g, state, n_randint(state, 100), 200);
fmpz_randtest(a, state, n_randint(state, 100));
fmpq_poly_evaluate_fmpz(x, f, a);
fmpq_poly_evaluate_fmpz(y, g, a);
fmpq_mul(x, x, y);
fmpq_poly_mul(f, f, g);
fmpq_poly_evaluate_fmpz(y, f, a);
result = (fmpq_equal(x, y));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(a);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ulong cflags = 0UL;
printf("exp_series....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and c */
for (i = 0; i < 200; i++)
{
fmpq_poly_t a, b;
long n = n_randint(state, 50) + 1;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_randtest_not_zero(a, state, n_randint(state, 50) + 1, 50);
fmpq_poly_set_coeff_ui(a, 0, 0UL);
fmpq_poly_canonicalise(a);
fmpq_poly_exp_series(b, a, n);
fmpq_poly_exp_series(a, a, n);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(b) ? 0 : 2;
result = (fmpq_poly_equal(a, b) && !cflags);
if (!result)
{
printf("FAIL:\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Check exp(a+b) = exp(a) * exp(b) */
for (i = 0; i < 500; i++)
{
fmpq_poly_t a, b, ab, expa, expb, expab, expa_expb;
long n = n_randint(state, 80) + 1;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(ab);
fmpq_poly_init(expa);
fmpq_poly_init(expb);
fmpq_poly_init(expab);
fmpq_poly_init(expa_expb);
fmpq_poly_randtest_not_zero(a, state, n_randint(state, 60) + 1, 80);
fmpq_poly_set_coeff_ui(a, 0, 0UL);
fmpq_poly_randtest_not_zero(b, state, n_randint(state, 60) + 1, 80);
fmpq_poly_set_coeff_ui(b, 0, 0UL);
fmpq_poly_add(ab, a, b);
fmpq_poly_exp_series(expab, ab, n);
fmpq_poly_exp_series(expa, a, n);
fmpq_poly_exp_series(expb, b, n);
fmpq_poly_mullow(expa_expb, expa, expb, n);
cflags |= fmpq_poly_is_canonical(expa) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(expb) ? 0 : 2;
cflags |= fmpq_poly_is_canonical(expab) ? 0 : 4;
result = (fmpq_poly_equal(expab, expa_expb) && !cflags);
if (!result)
{
printf("FAIL:\n");
printf("a = "), fmpq_poly_debug(a), printf("\n\n");
printf("b = "), fmpq_poly_debug(b), printf("\n\n");
printf("exp(a) = "), fmpq_poly_debug(expa), printf("\n\n");
printf("exp(b) = "), fmpq_poly_debug(expb), printf("\n\n");
printf("exp(ab) = "), fmpq_poly_debug(expab), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(ab);
fmpq_poly_clear(expa);
fmpq_poly_clear(expb);
fmpq_poly_clear(expab);
fmpq_poly_clear(expa_expb);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
ulong cflags = UWORD(0);
FLINT_TEST_INIT(state);
flint_printf("derivative....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_derivative(b, a);
fmpq_poly_derivative(a, a);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(b) ? 0 : 2;
result = (fmpq_poly_equal(a, b) && !cflags);
if (!result)
{
flint_printf("FAIL:\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Check constants have derivative zero */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_randtest(a, state, n_randint(state, 2), 200);
fmpq_poly_derivative(b, a);
cflags |= fmpq_poly_is_canonical(b) ? 0 : 1;
result = fmpq_poly_is_zero(b) && !cflags;
if (!result)
{
flint_printf("FAIL:\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Check (f g)' = f' g + f g' */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, c, d, lhs, rhs;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_init(d);
fmpq_poly_init(lhs);
fmpq_poly_init(rhs);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_mul(lhs, a, b);
fmpq_poly_derivative(lhs, lhs);
fmpq_poly_derivative(c, a);
fmpq_poly_derivative(d, b);
fmpq_poly_mul(c, c, b);
fmpq_poly_mul(d, a, d);
fmpq_poly_add(rhs, c, d);
cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2;
result = fmpq_poly_equal(lhs, rhs) && !cflags;
if (!result)
{
flint_printf("FAIL:\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
fmpq_poly_clear(d);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("evaluate_fmpq....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 1000; i++)
{
fmpz_t a, b;
fmpq_t x, y;
fmpq_poly_t f;
fmpz_init(a);
fmpz_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_poly_init(f);
fmpq_poly_randtest(f, state, n_randint(state, 80), 100);
fmpz_randtest(a, state, 80);
fmpz_randtest_not_zero(b, state, 80);
fmpz_set(fmpq_numref(x), a);
fmpz_set(fmpq_denref(x), a);
fmpq_canonicalise(x);
fmpq_poly_evaluate_fmpq(y, f, x);
fmpq_poly_evaluate_fmpq(x, f, x);
result = (fmpq_equal(x, y));
if (!result)
{
printf("FAIL:\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
fmpq_poly_debug(f), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_poly_clear(f);
}
/* Check that (f+g)(a) = f(a) + g(a) */
for (i = 0; i < 1000; i++)
{
fmpz_t a, b;
fmpq_t x, y, z;
fmpq_poly_t f, g;
fmpz_init(a);
fmpz_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_randtest(f, state, n_randint(state, 80), 100);
fmpq_poly_randtest(g, state, n_randint(state, 80), 100);
fmpz_randtest(a, state, 80);
fmpz_randtest_not_zero(b, state, 80);
fmpz_set(fmpq_numref(x), a);
fmpz_set(fmpq_denref(x), a);
fmpq_canonicalise(x);
fmpq_poly_evaluate_fmpq(y, f, x);
fmpq_poly_evaluate_fmpq(z, g, x);
fmpq_add(y, y, z);
fmpq_poly_add(f, f, g);
fmpq_poly_evaluate_fmpq(z, f, x);
result = (fmpq_equal(y, z));
if (!result)
{
printf("FAIL:\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
}
/* Check that (f*g)(a) = f(a) * g(a) */
for (i = 0; i < 1000; i++)
{
fmpz_t a, b;
fmpq_t x, y, z;
fmpq_poly_t f, g;
fmpz_init(a);
fmpz_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_randtest(f, state, n_randint(state, 50), 80);
fmpq_poly_randtest(g, state, n_randint(state, 50), 80);
fmpz_randtest(a, state, 80);
fmpz_randtest_not_zero(b, state, 80);
fmpz_set(fmpq_numref(x), a);
fmpz_set(fmpq_denref(x), a);
fmpq_canonicalise(x);
fmpq_poly_evaluate_fmpq(y, f, x);
fmpq_poly_evaluate_fmpq(z, g, x);
fmpq_mul(y, y, z);
fmpq_poly_mul(f, f, g);
fmpq_poly_evaluate_fmpq(z, f, x);
result = (fmpq_equal(y, z));
if (!result)
{
printf("FAIL:\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void _dgsl_rot_mp_sqrt_sigma_2(fmpq_poly_t rop, const fmpz_poly_t g, const mpfr_t sigma,
const int r, const long n, const mpfr_prec_t prec, const oz_flag_t flags) {
fmpq_poly_zero(rop);
fmpq_t r_q2;
fmpq_init(r_q2);
fmpq_set_si(r_q2, r, 1);
fmpq_mul(r_q2, r_q2, r_q2);
fmpq_neg(r_q2, r_q2);
fmpq_poly_set_coeff_fmpq(rop, 0, r_q2);
fmpq_clear(r_q2);
fmpq_poly_t g_q; fmpq_poly_init(g_q);
fmpq_poly_set_fmpz_poly(g_q, g);
fmpq_poly_t ng; fmpq_poly_init(ng);
fmpq_poly_oz_invert_approx(ng, g_q, n, prec, flags);
fmpq_poly_t ngt;
fmpq_poly_init(ngt);
fmpq_poly_oz_conjugate(ngt, ng, n);
fmpq_poly_t nggt;
fmpq_poly_init(nggt);
fmpq_poly_oz_mul(nggt, ng, ngt, n);
/**
We compute sqrt(g^-T · g^-1) to use it as the starting point for
convergence on sqrt(σ^2 · g^-T · g^-1 - r^2) below. We can compute the
former with less precision than the latter
*/
mpfr_t norm;
mpfr_init2(norm, prec);
fmpz_poly_eucl_norm_mpfr(norm, g, MPFR_RNDN);
double p = mpfr_get_d(norm, MPFR_RNDN);
/**
|g^-1| ~= 1/|g|
|g^-T| ~= |g^-1|
|g^-1·g^-T| ~= sqrt(n)·|g^-T|·|g^-1|
*/
fmpq_poly_t sqrt_start; fmpq_poly_init(sqrt_start);
p = log2(n) + 4*log2(p);
int fail = -1;
while (fail) {
p = 2*p;
if (fail<0)
fail = fmpq_poly_oz_sqrt_approx_db(sqrt_start, nggt, n, p, prec/2, flags, NULL);
else
fail = fmpq_poly_oz_sqrt_approx_db(sqrt_start, nggt, n, p, prec/2, flags, sqrt_start);
if(fail)
fprintf(stderr, "FAILED for precision %7.1f with code (%d), doubling precision.\n", p, fail);
}
fmpq_t sigma2;
fmpq_init(sigma2);
fmpq_set_mpfr(sigma2, sigma, MPFR_RNDN);
fmpq_poly_scalar_mul_fmpq(sqrt_start, sqrt_start, sigma2);
fmpq_mul(sigma2, sigma2, sigma2);
fmpq_poly_scalar_mul_fmpq(nggt, nggt, sigma2);
fmpq_clear(sigma2);
fmpq_poly_add(rop, rop, nggt);
p = p + 2*log2(mpfr_get_d(sigma, MPFR_RNDN));
fmpq_poly_oz_sqrt_approx_babylonian(rop, rop, n, p, prec, flags, sqrt_start);
mpfr_clear(norm);
fmpq_poly_clear(g_q);
fmpq_poly_clear(ng);
fmpq_poly_clear(ngt);
fmpq_poly_clear(nggt);
fmpq_poly_clear(sqrt_start);
}
int
main(void)
{
int i, result;
flint_rand_t state;
ulong cflags = 0UL;
printf("sub....");
fflush(stdout);
flint_randinit(state);
/* Check a - b = a + neg(b) */
for (i = 0; i < 10000; i++)
{
fmpq_poly_t a, b, c, d;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_init(d);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_sub(c, a, b);
fmpq_poly_neg(b, b);
fmpq_poly_add(d, a, b);
cflags |= fmpq_poly_is_canonical(c) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(d) ? 0 : 2;
result = (fmpq_poly_equal(c, d) && !cflags);
if (!result)
{
printf("FAIL:\n\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(c), printf("\n\n");
fmpq_poly_debug(d), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
fmpq_poly_clear(d);
}
/* Check aliasing of a and c */
for (i = 0; i < 10000; i++)
{
fmpq_poly_t a, b, c;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_sub(c, a, b);
fmpq_poly_sub(a, a, b);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(c) ? 0 : 2;
result = (fmpq_poly_equal(a, c) && !cflags);
if (!result)
{
printf("FAIL:\n\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(c), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
}
/* Check aliasing of b and c */
for (i = 0; i < 10000; i++)
{
fmpq_poly_t a, b, c;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_sub(c, a, b);
fmpq_poly_sub(b, a, b);
cflags |= fmpq_poly_is_canonical(b) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(c) ? 0 : 2;
result = (fmpq_poly_equal(b, c) && !cflags);
if (!result)
{
printf("FAIL:\n\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(c), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
