int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("init/clear....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_mat_t a;
slong j, k;
slong rows = n_randint(state, 100);
slong cols = n_randint(state, 100);
fmpq_mat_init(a, rows, cols);
for (j = 0; j < rows; j++)
for (k = 0; k < cols; k++)
fmpq_zero(fmpq_mat_entry(a, j, k));
fmpq_mat_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
fmpr_get_fmpq(fmpq_t y, const fmpr_t x)
{
if (fmpr_is_zero(x))
{
fmpq_zero(y);
}
else if (fmpr_is_special(x) || COEFF_IS_MPZ(*fmpr_expref(x)))
{
printf("exception: fmpr_get_fmpq: cannot convert to rational\n");
abort();
}
else
{
long exp = *fmpr_expref(x);
fmpz_set_ui(fmpq_denref(y), 1UL);
if (exp >= 0)
{
fmpz_mul_2exp(fmpq_numref(y), fmpr_manref(x), exp);
}
else
{
fmpz_set(fmpq_numref(y), fmpr_manref(x));
fmpz_mul_2exp(fmpq_denref(y), fmpq_denref(y), -exp);
}
}
}
void fmpq_poly_resultant(fmpq_t r, const fmpq_poly_t f, const fmpq_poly_t g)
{
const long len1 = f->length;
const long len2 = g->length;
if (len1 == 0 || len2 == 0)
{
fmpq_zero(r);
}
else
{
if (len1 >= len2)
{
_fmpq_poly_resultant(fmpq_numref(r), fmpq_denref(r),
f->coeffs, f->den, len1,
g->coeffs, g->den, len2);
}
else
{
_fmpq_poly_resultant(fmpq_numref(r), fmpq_denref(r),
g->coeffs, g->den, len2,
f->coeffs, f->den, len1);
if (((len1 | len2) & 1L) == 0L)
fmpq_neg(r, r);
}
}
}
static void
_fmpq_mat_sum_of_squares(fmpq_t res, const fmpq_mat_t Q)
{
slong i, j;
fmpq_zero(res);
for (i = 0; i < fmpq_mat_nrows(Q); i++)
{
for (j = 0; j < fmpq_mat_ncols(Q); j++)
{
fmpq_addmul(res, fmpq_mat_entry(Q, i, j), fmpq_mat_entry(Q, i, j));
}
}
}
void fmpq_mat_one(fmpq_mat_t mat)
{
slong i, j, min;
for (i = 0; i < mat->r; i++)
for (j = 0; j < mat->c; j++)
fmpq_zero(fmpq_mat_entry(mat, i, j));
min = FLINT_MIN(mat->r, mat->c);
for (i = 0; i < min; i++)
fmpq_one(fmpq_mat_entry(mat, i, i));
}
void
arf_get_fmpq(fmpq_t y, const arf_t x)
{
if (arf_is_zero(x))
{
fmpq_zero(y);
}
else if (arf_is_special(x) || !ARF_IS_LAGOM(x))
{
flint_printf("exception: arf_get_fmpq: cannot convert to rational\n");
abort();
}
else
{
fmpz_t man, exp;
slong e;
fmpz_init(man);
fmpz_init(exp);
arf_get_fmpz_2exp(man, exp, x);
e = *exp;
fmpz_set_ui(fmpq_denref(y), UWORD(1));
if (e >= 0)
{
fmpz_mul_2exp(fmpq_numref(y), man, e);
}
else
{
fmpz_set(fmpq_numref(y), man);
fmpz_mul_2exp(fmpq_denref(y), fmpq_denref(y), -e);
}
fmpz_clear(man);
fmpz_clear(exp);
}
}
void set_zero(ElementType& result) const {fmpq_zero(&result);}
void
fmpz_holonomic_get_nth_fmpq(fmpq_t res, const fmpz_holonomic_t op, const fmpq * initial, long n0, long n)
{
long r = fmpz_holonomic_order(op);
if (r == 0)
{
fmpq_zero(res);
return;
}
else if (n < n0)
{
printf("not implemented\n");
abort();
}
else if (n - n0 < r)
{
fmpq_set(res, initial + n - n0);
return;
}
else
{
fmpz_mat_t M;
long i;
fmpz_t Q;
fmpz_mat_init(M, r, r);
fmpz_init(Q);
fmpz_holonomic_forward_fmpz_mat(M, Q, op, n0, n - n0 - r + 1);
{
fmpz_t g, t;
fmpz_init(g);
fmpz_init(t);
fmpz_one(g);
for (i = 0; i < r; i++)
fmpz_lcm(g, g, fmpq_denref(initial + i));
fmpz_divexact(t, g, fmpq_denref(initial + 0));
fmpz_mul(t, t, fmpq_numref(initial + 0));
fmpz_mul(fmpz_mat_entry(M, r - 1, 0), fmpz_mat_entry(M, r - 1, 0), t);
for (i = 1; i < r; i++)
{
fmpz_divexact(t, g, fmpq_denref(initial + i));
fmpz_mul(t, t, fmpq_numref(initial + i));
fmpz_addmul(fmpz_mat_entry(M, r - 1, 0), fmpz_mat_entry(M, r - 1, i), t);
}
fmpz_set(fmpq_numref(res), fmpz_mat_entry(M, r - 1, 0));
fmpz_mul(fmpq_denref(res), Q, g);
fmpq_canonicalise(res);
fmpz_clear(g);
fmpz_clear(t);
}
fmpz_mat_clear(M);
fmpz_clear(Q);
}
}
int
main(void)
{
int i;
flint_rand_t state;
flint_randinit(state);
printf("bsplit_sum_abpq....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq *ab, *pq;
fmpq_t s1, s2, t, pqp;
fmpq_bsplit_t sum;
long k, n;
n = n_randint(state, 40);
ab = _fmpq_vec_init(n);
pq = _fmpq_vec_init(n);
fmpq_init(s1);
fmpq_init(s2);
fmpq_init(pqp);
fmpq_init(t);
for (k = 0; k < n; k++) fmpq_randtest(ab + k, state, 10);
for (k = 0; k < n; k++) fmpq_randtest(pq + k, state, 10);
fmpq_bsplit_init(sum);
fmpq_bsplit_sum_abpq(sum, ab, pq, 0, n);
fmpq_bsplit_get_fmpq(s1, sum);
fmpq_zero(s2);
fmpq_one(pqp);
for (k = 0; k < n; k++)
{
fmpq_mul(pqp, pqp, pq + k);
fmpq_mul(t, pqp, ab + k);
fmpq_add(s2, s2, t);
}
if (!fmpq_is_canonical(s1) || !fmpq_equal(s1, s2))
{
printf("FAIL\n");
printf("(a/b) = ");
for (k = 0; k < n; k++) fmpq_print(ab+k), printf(" ");
printf("\n");
printf("(p/q) = ");
for (k = 0; k < n; k++) fmpq_print(pq+k), printf(" ");
printf("\n");
printf("s1: ");
fmpq_print(s1);
printf("\n");
printf("s2: ");
fmpq_print(s2);
printf("\n");
abort();
}
/* Check numerical evaluation */
{
mpfr_t f1, f2;
mpfr_prec_t prec;
prec = 5 + n_randint(state, 1000);
mpfr_init2(f1, prec);
mpfr_init2(f2, prec);
fmpq_bsplit_get_mpfr(f1, sum);
fmpq_get_mpfr(f2, s1, MPFR_RNDN);
mpfr_sub(f1, f1, f2, MPFR_RNDN);
if (!mpfr_zero_p(f1) &&
!(mpfr_get_exp(f1) <= mpfr_get_exp(f2) - prec + 3))
{
printf("FAIL: numerical evaluation\n");
printf("%ld, %ld, %ld\n", prec, mpfr_get_exp(f1),
mpfr_get_exp(f2) - prec + 3);
abort();
}
mpfr_clear(f1);
mpfr_clear(f2);
}
fmpq_bsplit_clear(sum);
fmpq_clear(s1);
fmpq_clear(s2);
fmpq_clear(pqp);
fmpq_clear(t);
_fmpq_vec_clear(ab, n);
_fmpq_vec_clear(pq, n);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
