int main(void)
{
flint_rand_t state;
slong i;
flint_printf("partitions_fmpz_ui_threaded....");
fflush(stdout);
flint_randinit(state);
flint_set_num_threads(2);
{
fmpz_t p;
fmpz * v;
fmpz_init(p);
v = _fmpz_vec_init(NUM);
arith_number_of_partitions_vec(v, NUM);
for (i = 0; i < NUM; i++)
{
partitions_fmpz_ui(p, i);
if (!fmpz_equal(p, v + i))
{
flint_printf("FAIL:\n");
flint_printf("p(%wd) does not agree with power series\n", i);
flint_printf("Computed p(%wd): ", i); fmpz_print(p); flint_printf("\n");
flint_printf("Expected: "); fmpz_print(v + i); flint_printf("\n");
abort();
}
}
_fmpz_vec_clear(v, NUM);
for (i = 0; testdata[i][0] != 0; i++)
{
partitions_fmpz_ui(p, testdata[i][0]);
if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1])
{
flint_printf("FAIL:\n");
flint_printf("p(%wd) does not agree with known value mod 10^9\n",
testdata[i][0]);
flint_printf("Computed: %wu\n", fmpz_fdiv_ui(p, 1000000000));
flint_printf("Expected: %wu\n", testdata[i][1]);
abort();
}
}
fmpz_clear(p);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return 0;
}
int main(void)
{
flint_rand_t state;
fmpz_t p;
fmpz * v;
long i;
printf("number_of_partitions....");
fflush(stdout);
flint_randinit(state);
fmpz_init(p);
v = _fmpz_vec_init(3000);
number_of_partitions_vec(v, 3000);
for (i = 0; i < 3000; i++)
{
number_of_partitions(p, i);
if (!fmpz_equal(p, v + i))
{
printf("FAIL:\n");
printf("p(%ld) does not agree with power series\n", i);
printf("Computed p(%ld): ", i); fmpz_print(p); printf("\n");
printf("Expected: "); fmpz_print(v + i); printf("\n");
abort();
}
}
_fmpz_vec_clear(v, 3000);
for (i = 0; testdata[i][0] != 0; i++)
{
number_of_partitions(p, testdata[i][0]);
if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1])
{
printf("FAIL:\n");
printf("p(%ld) does not agree with known value mod 10^9\n",
testdata[i][0]);
printf("Computed: %lu\n", fmpz_fdiv_ui(p, 1000000000));
printf("Expected: %lu\n", testdata[i][1]);
abort();
}
}
fmpz_clear(p);
flint_randclear(state);
mpfr_free_cache();
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main(void)
{
fmpz_t p;
fmpz * v;
slong i;
FLINT_TEST_INIT(state);
flint_printf("number_of_partitions....");
fflush(stdout);
fmpz_init(p);
v = _fmpz_vec_init(3000);
arith_number_of_partitions_vec(v, 3000);
for (i = 0; i < 3000; i++)
{
arith_number_of_partitions(p, i);
if (!fmpz_equal(p, v + i))
{
flint_printf("FAIL:\n");
flint_printf("p(%wd) does not agree with power series\n", i);
flint_printf("Computed p(%wd): ", i); fmpz_print(p); flint_printf("\n");
flint_printf("Expected: "); fmpz_print(v + i); flint_printf("\n");
abort();
}
}
_fmpz_vec_clear(v, 3000);
for (i = 0; testdata[i][0] != 0; i++)
{
arith_number_of_partitions(p, testdata[i][0]);
if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1])
{
flint_printf("FAIL:\n");
flint_printf("p(%wd) does not agree with known value mod 10^9\n",
testdata[i][0]);
flint_printf("Computed: %wu\n", fmpz_fdiv_ui(p, 1000000000));
flint_printf("Expected: %wu\n", testdata[i][1]);
abort();
}
}
fmpz_clear(p);
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
fmpz_mat_CRT_ui(fmpz_mat_t res, const fmpz_mat_t mat1,
const fmpz_t m1, const nmod_mat_t mat2, int sign)
{
long i, j;
mp_limb_t c;
mp_limb_t m2 = mat2->mod.n;
mp_limb_t m2inv = mat2->mod.ninv;
fmpz_t m1m2;
c = fmpz_fdiv_ui(m1, m2);
c = n_invmod(c, m2);
if (c == 0)
{
printf("Exception in fmpz_mat_CRT_ui: m1 not invertible modulo m2!\n");
abort();
}
fmpz_init(m1m2);
fmpz_mul_ui(m1m2, m1, m2);
for (i = 0; i < mat1->r; i++)
{
for (j = 0; j < mat1->c; j++)
_fmpz_CRT_ui_precomp(fmpz_mat_entry(res, i, j),
fmpz_mat_entry(mat1, i, j), m1,
nmod_mat_entry(mat2, i, j), m2, m2inv, m1m2, c, sign);
}
fmpz_clear(m1m2);
}
void
fmpz_gcd(fmpz_t f, const fmpz_t g, const fmpz_t h)
{
fmpz c1 = *g;
fmpz c2 = *h;
if (fmpz_is_zero(g))
{
fmpz_abs(f, h);
return;
}
if (fmpz_is_zero(h))
{
fmpz_abs(f, g);
return;
}
if (!COEFF_IS_MPZ(c1)) /* g is small */
{
if (!COEFF_IS_MPZ(c2)) /* h is also small */
{
fmpz_set_si(f, z_gcd(c1, c2));
}
else /* h is large, but g is small */
{
fmpz c2d = fmpz_fdiv_ui(h, FLINT_ABS(c1));
fmpz_set_si(f, z_gcd(c1, c2d));
}
}
else
{
if (!COEFF_IS_MPZ(c2)) /* h is small, but g is large */
{
fmpz c1d = fmpz_fdiv_ui(g, FLINT_ABS(c2));
fmpz_set_si(f, z_gcd(c2, c1d));
}
else /* g and h are both large */
{
__mpz_struct *mpz_ptr = _fmpz_promote(f); /* aliasing fine as g, h already large */
mpz_gcd(mpz_ptr, COEFF_TO_PTR(c1), COEFF_TO_PTR(c2));
_fmpz_demote_val(f); /* gcd may be small */
}
}
}
void
_fmpz_vec_get_nmod_vec(mp_ptr res, const fmpz * poly, long len, nmod_t mod)
{
long i;
for (i = 0; i < len; i++)
res[i] = fmpz_fdiv_ui(poly + i, mod.n);
}
void fmpz_powm(fmpz_t f, const fmpz_t g, const fmpz_t e, const fmpz_t m)
{
if (fmpz_sgn(m) <= 0)
{
flint_printf("Exception (fmpz_powm). Modulus is less than 1.\n");
abort();
}
else if (!COEFF_IS_MPZ(*e)) /* e is small */
{
fmpz_powm_ui(f, g, *e, m);
}
else /* e is large */
{
if (!COEFF_IS_MPZ(*m)) /* m is small */
{
ulong g1 = fmpz_fdiv_ui(g, *m);
mpz_t g2, m2;
__mpz_struct *mpz_ptr;
flint_mpz_init_set_ui(g2, g1);
flint_mpz_init_set_ui(m2, *m);
mpz_ptr = _fmpz_promote(f);
mpz_powm(mpz_ptr, g2, COEFF_TO_PTR(*e), m2);
mpz_clear(g2);
mpz_clear(m2);
_fmpz_demote_val(f);
}
else /* m is large */
{
if (!COEFF_IS_MPZ(*g)) /* g is small */
{
mpz_t g2;
__mpz_struct *mpz_ptr;
flint_mpz_init_set_si(g2, *g);
mpz_ptr = _fmpz_promote(f);
mpz_powm(mpz_ptr, g2, COEFF_TO_PTR(*e), COEFF_TO_PTR(*m));
mpz_clear(g2);
_fmpz_demote_val(f);
}
else /* g is large */
{
__mpz_struct *mpz_ptr = _fmpz_promote(f);
mpz_powm(mpz_ptr,
COEFF_TO_PTR(*g), COEFF_TO_PTR(*e), COEFF_TO_PTR(*m));
_fmpz_demote_val(f);
}
}
}
}
void
arb_sin_cos_pi(arb_t s, arb_t c, const arb_t x, long prec)
{
arb_t t;
arb_t u;
fmpz_t v;
if (arf_cmpabs_2exp_si(arb_midref(x), FLINT_MAX(65536, (4*prec))) > 0)
{
arf_zero(arb_midref(s));
mag_one(arb_radref(s));
arf_zero(arb_midref(c));
mag_one(arb_radref(c));
return;
}
arb_init(t);
arb_init(u);
fmpz_init(v);
arb_mul_2exp_si(t, x, 1);
arf_get_fmpz(v, arb_midref(t), ARF_RND_NEAR);
arb_sub_fmpz(t, t, v, prec);
arb_const_pi(u, prec);
arb_mul(t, t, u, prec);
arb_mul_2exp_si(t, t, -1);
switch (fmpz_fdiv_ui(v, 4))
{
case 0:
arb_sin_cos(s, c, t, prec);
break;
case 1:
arb_sin_cos(c, s, t, prec);
arb_neg(c, c);
break;
case 2:
arb_sin_cos(s, c, t, prec);
arb_neg(s, s);
arb_neg(c, c);
break;
default:
arb_sin_cos(c, s, t, prec);
arb_neg(s, s);
break;
}
fmpz_clear(v);
arb_clear(t);
arb_clear(u);
}
mp_limb_t _fmpz_poly_evaluate_mod(const fmpz * poly, slong len, mp_limb_t a,
mp_limb_t n, mp_limb_t ninv)
{
mp_limb_t c, res = 0;
while (len--)
{
c = fmpz_fdiv_ui(poly + len, n);
res = n_addmod(n_mulmod2_preinv(res, a, n, ninv), c, n);
}
return res;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("set_ui_smod....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, mz;
mp_limb_t m, r;
fmpz_init(a);
fmpz_init(b);
fmpz_init(mz);
do { m = n_randtest(state); } while (m < 2);
fmpz_set_ui(mz, m);
fmpz_randtest_mod_signed(a, state, mz);
r = fmpz_fdiv_ui(a, m);
fmpz_set_ui_smod(b, r, m);
if (!fmpz_equal(a, b))
{
flint_printf("FAIL:\n");
flint_printf("a: "); fmpz_print(a); flint_printf("\n");
flint_printf("m: %wu\n", m);
flint_printf("r: %wu\n", m);
flint_printf("b: "); fmpz_print(b); flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(mz);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
_fmpz_vec_get_nmod_poly(nmod_poly_t res, const fmpz * coeffs, slong len)
{
if (len == 0)
{
nmod_poly_zero(res);
}
else
{
slong i;
nmod_poly_fit_length(res, len);
for (i = 0; i < len; i++)
res->coeffs[i] = fmpz_fdiv_ui(coeffs + i, res->mod.n);
_nmod_poly_set_length(res, len);
_nmod_poly_normalise(res);
}
}
void
arb_bernoulli_fmpz(arb_t res, const fmpz_t n, slong prec)
{
if (fmpz_cmp_ui(n, UWORD_MAX) <= 0)
{
if (fmpz_sgn(n) >= 0)
arb_bernoulli_ui(res, fmpz_get_ui(n), prec);
else
arb_zero(res);
}
else if (fmpz_is_odd(n))
{
arb_zero(res);
}
else
{
arb_t t;
slong wp;
arb_init(t);
wp = prec + 2 * fmpz_bits(n);
/* zeta(n) ~= 1 */
arf_one(arb_midref(res));
mag_one(arb_radref(res));
mag_mul_2exp_si(arb_radref(res), arb_radref(res), WORD_MIN);
/* |B_n| = 2 * n! / (2*pi)^n * zeta(n) */
arb_gamma_fmpz(t, n, wp);
arb_mul_fmpz(t, t, n, wp);
arb_mul(res, res, t, wp);
arb_const_pi(t, wp);
arb_mul_2exp_si(t, t, 1);
arb_pow_fmpz(t, t, n, wp);
arb_div(res, res, t, prec);
arb_mul_2exp_si(res, res, 1);
if (fmpz_fdiv_ui(n, 4) == 0)
arb_neg(res, res);
arb_clear(t);
}
}
mp_limb_t fmpz_poly_evaluate_mod(const fmpz_poly_t poly, mp_limb_t a,
mp_limb_t n)
{
if (poly->length == 0)
return 0;
if (a == 0)
{
mp_limb_t res;
res = fmpz_fdiv_ui(poly->coeffs, n);
return res;
}
else
{
mp_limb_t ninv;
ninv = n_preinvert_limb(n);
return _fmpz_poly_evaluate_mod(poly->coeffs, poly->length, a, n, ninv);
}
}
void
fmpz_randtest_mod_signed(fmpz_t f, flint_rand_t state, const fmpz_t m)
{
/* Randomly generate m/2 when included in the range */
if ((n_randlimb(state) % 32 == 1) && (fmpz_fdiv_ui(m, 2) == 0))
{
fmpz_fdiv_q_ui(f, m, UWORD(2));
}
else
{
fmpz_t t;
fmpz_init(t);
fmpz_tdiv_q_ui(t, m, UWORD(2));
fmpz_randtest_mod(t, state, t);
if (n_randlimb(state) & UWORD(1))
{
fmpz_neg(t, t);
}
fmpz_set(f, t);
fmpz_clear(t);
}
}
int main()
{
slong i, j;
int sign;
fmpz_t input;
fmpz_t result;
fmpz_t r1;
fmpz_t m1;
fmpz_t mprod;
ulong r2, m2;
FLINT_TEST_INIT(state);
flint_printf("CRT_ui....");
fflush(stdout);
fmpz_init(input);
fmpz_init(result);
fmpz_init(r1);
fmpz_init(m1);
fmpz_init(mprod);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
slong nprimes;
m2 = n_randtest_prime(state, 0);
nprimes = 1 + n_randint(state, 4);
fmpz_set_ui(m1, UWORD(1));
for (j = 0; j < nprimes; )
{
ulong t = n_randtest_prime(state, 0);
if (t != m2)
{
fmpz_mul_ui(m1, m1, t);
j++;
}
}
fmpz_mul_ui(mprod, m1, m2);
sign = n_randint(state, 2);
if (sign)
fmpz_randtest_mod_signed(input, state, mprod);
else
fmpz_randtest_mod(input, state, mprod);
fmpz_mod(r1, input, m1);
r2 = fmpz_fdiv_ui(input, m2);
fmpz_CRT_ui(result, r1, m1, r2, m2, sign);
if (!fmpz_equal(result, input))
{
flint_printf("FAIL:\n");
flint_printf("m1: "); fmpz_print(m1); flint_printf("\n");
flint_printf("m2: %wu\n", m2);
flint_printf("m1*m2: "); fmpz_print(mprod); flint_printf("\n");
flint_printf("input: "); fmpz_print(input); flint_printf("\n");
flint_printf("r1: "); fmpz_print(r1); flint_printf("\n");
flint_printf("r2: %wu\n", r2);
flint_printf("result: "); fmpz_print(result); flint_printf("\n");
flint_printf("%wd Equalness: %d\n", i, fmpz_equal(result, input));
flint_printf("\n");
abort();
}
}
fmpz_clear(input);
fmpz_clear(result);
fmpz_clear(r1);
fmpz_clear(m1);
fmpz_clear(mprod);
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
long i, j;
int sign;
fmpz_t input;
fmpz_t result;
fmpz_t r1;
fmpz_t m1;
fmpz_t mprod;
ulong r2, m2;
flint_rand_t state;
printf("CRT_ui....");
fflush(stdout);
fmpz_init(input);
fmpz_init(result);
fmpz_init(r1);
fmpz_init(m1);
fmpz_init(mprod);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
long nprimes;
m2 = n_randtest_prime(state, 0);
nprimes = 1 + n_randint(state, 4);
fmpz_set_ui(m1, 1UL);
for (j = 0; j < nprimes; )
{
ulong t = n_randtest_prime(state, 0);
if (t != m2)
{
fmpz_mul_ui(m1, m1, t);
j++;
}
}
fmpz_mul_ui(mprod, m1, m2);
sign = n_randint(state, 2);
if (sign)
fmpz_randtest_mod_signed(input, state, mprod);
else
fmpz_randtest_mod(input, state, mprod);
fmpz_mod(r1, input, m1);
r2 = fmpz_fdiv_ui(input, m2);
if (sign)
fmpz_CRT_ui(result, r1, m1, r2, m2);
else
fmpz_CRT_ui_unsigned(result, r1, m1, r2, m2);
if (!fmpz_equal(result, input))
{
printf("FAIL:\n");
printf("m1: "); fmpz_print(m1); printf("\n");
printf("m2: %lu\n", m2);
printf("m1*m2: "); fmpz_print(mprod); printf("\n");
printf("input: "); fmpz_print(input); printf("\n");
printf("r1: "); fmpz_print(r1); printf("\n");
printf("r2: %lu\n", r2);
printf("result: "); fmpz_print(result); printf("\n");
printf("%ld Equalness: %d\n", i, fmpz_equal(result, input));
printf("\n");
abort();
}
}
fmpz_clear(input);
fmpz_clear(result);
fmpz_clear(r1);
fmpz_clear(m1);
fmpz_clear(mprod);
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
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()
{
slong iter;
flint_rand_t state;
flint_printf("get_mpn_fixed_mod_pi4....");
fflush(stdout);
flint_randinit(state);
/* _flint_rand_init_gmp(state); */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arf_t x;
int octant;
fmpz_t q;
mp_ptr w;
arb_t wb, t, u;
mp_size_t wn;
slong prec, prec2;
int success;
mp_limb_t error;
prec = 2 + n_randint(state, 10000);
wn = 1 + n_randint(state, 200);
prec2 = FLINT_MAX(prec, wn * FLINT_BITS) + 100;
arf_init(x);
arb_init(wb);
arb_init(t);
arb_init(u);
fmpz_init(q);
w = flint_malloc(sizeof(mp_limb_t) * wn);
arf_randtest(x, state, prec, 14);
/* this should generate numbers close to multiples of pi/4 */
if (n_randint(state, 4) == 0)
{
arb_const_pi(t, prec);
arb_mul_2exp_si(t, t, -2);
fmpz_randtest(q, state, 200);
arb_mul_fmpz(t, t, q, prec);
arf_add(x, x, arb_midref(t), prec, ARF_RND_DOWN);
}
arf_abs(x, x);
success = _arb_get_mpn_fixed_mod_pi4(w, q, &octant, &error, x, wn);
if (success)
{
/* could round differently */
if (fmpz_fdiv_ui(q, 8) != octant)
{
flint_printf("bad octant\n");
abort();
}
_arf_set_mpn_fixed(arb_midref(wb), w, wn, wn, 0, FLINT_BITS * wn, ARB_RND);
mag_set_ui_2exp_si(arb_radref(wb), error, -FLINT_BITS * wn);
arb_const_pi(u, prec2);
arb_mul_2exp_si(u, u, -2);
arb_set(t, wb);
if (octant % 2 == 1)
arb_sub(t, u, t, prec2);
arb_addmul_fmpz(t, u, q, prec2);
if (!arb_contains_arf(t, x))
{
flint_printf("FAIL (containment)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("q = "); fmpz_print(q); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
flint_printf("t = "); arb_printd(t, 50); flint_printf("\n\n");
abort();
}
arb_const_pi(t, prec2);
arb_mul_2exp_si(t, t, -2);
if (arf_sgn(arb_midref(wb)) < 0 ||
arf_cmp(arb_midref(wb), arb_midref(t)) >= 0)
{
flint_printf("FAIL (expected 0 <= w < pi/4)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
abort();
}
}
flint_free(w);
fmpz_clear(q);
arf_clear(x);
arb_clear(wb);
arb_clear(t);
arb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("forward_nmod_mat....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmpz_holonomic_t op;
fmpz_mat_t M1;
fmpz_t Q1;
nmod_mat_t M2, L, R;
mp_limb_t Q2;
long start, n, r;
mp_limb_t p;
fmpz_holonomic_init(op);
fmpz_holonomic_randtest(op, state, 4, 4, 10);
r = fmpz_holonomic_order(op);
start = n_randint(state, 10);
n = n_randint(state, 100);
p = n_randtest_prime(state, 0);
fmpz_mat_init(M1, r, r);
fmpz_init(Q1);
nmod_mat_init(M2, r, r, p);
nmod_mat_init(L, r, r, p);
nmod_mat_init(R, r, r, p);
fmpz_holonomic_forward_fmpz_mat(M1, Q1, op, start, n);
fmpz_holonomic_forward_nmod_mat(M2, &Q2, op, start, n);
fmpz_mat_get_nmod_mat(L, M1);
nmod_mat_scalar_mul(L, L, Q2);
nmod_mat_scalar_mul(R, M2, fmpz_fdiv_ui(Q1, p));
/* check Q2 * M1 = Q1 * M2 */
if (!nmod_mat_equal(L, R))
{
printf("FAIL\n");
fmpz_holonomic_print(op, "n", "Sn"); printf("\n\n");
printf("start = %lu, n = %lu\n", start, n);
fmpz_mat_print_pretty(M1); printf("\n\n");
fmpz_print(Q1); printf("\n\n");
nmod_mat_print_pretty(M2); printf("\n\n");
printf("%lu\n\n", Q2);
abort();
}
fmpz_mat_clear(M1);
fmpz_clear(Q1);
nmod_mat_clear(M2);
nmod_mat_clear(L);
nmod_mat_clear(R);
fmpz_holonomic_clear(op);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
