void
fmpz_mat_det_divisor(fmpz_t d, const fmpz_mat_t A)
{
fmpz_mat_t X, B;
fmpz_t t, u, v, mod;
long i, n;
int success;
n = A->r;
fmpz_mat_init(B, n, 1);
fmpz_mat_init(X, n, 1);
fmpz_init(t);
fmpz_init(u);
fmpz_init(v);
fmpz_init(mod);
/* Create a "random" vector */
for (i = 0; i < n; i++)
{
fmpz_set_si(fmpz_mat_entry(B, i, 0), 2*(i % 2) - 1);
}
success = fmpz_mat_solve_dixon(X, mod, A, B);
if (success)
{
fmpz_one(d);
for (i = 0; i < n; i++)
{
fmpz_mul(t, d, fmpz_mat_entry(X, i, 0));
fmpz_fdiv_qr(u, t, t, mod);
if (!_fmpq_reconstruct_fmpz(u, v, t, mod))
{
printf("Exception: fmpz_mat_det_divisor: "
"rational reconstruction failed!\n");
abort();
}
fmpz_mul(d, v, d);
}
}
else
{
fmpz_zero(d);
}
fmpz_mat_clear(B);
fmpz_mat_clear(X);
fmpz_clear(t);
fmpz_clear(u);
fmpz_clear(v);
fmpz_clear(mod);
}
void
_padic_log_balanced(fmpz_t z, const fmpz_t y, long v, const fmpz_t p, long N)
{
fmpz_t pv, pN, r, t, u;
long val;
padic_inv_t S;
fmpz_init(pv);
fmpz_init(pN);
fmpz_init(r);
fmpz_init(t);
fmpz_init(u);
_padic_inv_precompute(S, p, N);
fmpz_set(t, y);
fmpz_set(pv, p);
fmpz_pow_ui(pN, p, N);
fmpz_zero(z);
val = 1;
/*
TODO: Abort earlier if larger than $p^N$, possible
with variable precision?
*/
while (!fmpz_is_zero(t))
{
fmpz_mul(pv, pv, pv);
fmpz_fdiv_qr(t, r, t, pv);
if (!fmpz_is_zero(t))
{
fmpz_mul(t, t, pv);
fmpz_add_ui(u, r, 1);
_padic_inv_precomp(u, u, S);
fmpz_mul(t, t, u);
fmpz_mod(t, t, pN);
}
if (!fmpz_is_zero(r))
{
fmpz_neg(r, r);
_padic_log_bsplit(r, r, val, p, N);
fmpz_sub(z, z, r);
}
val *= 2;
}
fmpz_clear(pv);
fmpz_clear(pN);
fmpz_clear(r);
fmpz_clear(t);
fmpz_clear(u);
_padic_inv_clear(S);
}
void sample(void * arg, ulong count)
{
info_t * info = (info_t *) arg;
slong limbs = info->limbs, i, j;
int algo = info->algo;
int scale = 200;
FLINT_TEST_INIT(state);
fmpz_t a, b, c, r;
fmpz_preinvn_t inv;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(r);
for (i = 0; i < count; i++)
{
fmpz_randbits(a, state, (2*limbs - 1)*FLINT_BITS);
fmpz_randbits(b, state, limbs*FLINT_BITS);
fmpz_preinvn_init(inv, b);
prof_start();
if (algo == 1)
{
for (j = 0; j < scale; j++)
{
fmpz_fdiv_qr_preinvn(c, r, a, b, inv);
}
} else
{
for (j = 0; j < scale; j++)
{
fmpz_fdiv_qr(c, r, a, b);
}
}
prof_stop();
}
fmpz_preinvn_clear(inv);
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(r);
flint_randclear(state);
}
void
_fmpz_poly_pseudo_divrem_basecase(fmpz * Q, fmpz * R, ulong * d,
const fmpz * A, long lenA, const fmpz * B,
long lenB)
{
const fmpz * leadB = B + (lenB - 1);
long iQ = lenA - lenB, iR = lenA - 1;
fmpz_t rem;
fmpz_init(rem);
*d = 0;
_fmpz_vec_zero(Q, lenA - lenB + 1);
if (R != A)
_fmpz_vec_set(R, A, lenA);
while (iR >= lenB - 1)
{
fmpz_fdiv_qr(Q + iQ, rem, R + iR, leadB);
if (!fmpz_is_zero(rem))
{
_fmpz_vec_scalar_mul_fmpz(Q, Q, lenA - lenB + 1, leadB);
fmpz_set(Q + iQ, R + iR);
_fmpz_vec_scalar_mul_fmpz(R, R, lenA, leadB);
(*d)++;
}
if (lenB > 1)
_fmpz_vec_scalar_submul_fmpz(R + (iR - lenB + 1), B, lenB - 1, Q + iQ);
fmpz_zero(R + iR);
iR--;
iQ--;
}
fmpz_clear(rem);
}
int
arf_root(arf_ptr z, arf_srcptr x, ulong k, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, zn, val;
mp_srcptr xptr;
mp_ptr tmp, zptr;
mpfr_t xf, zf;
fmpz_t q, r;
int inexact;
if (k == 0)
{
arf_nan(z);
return 0;
}
if (k == 1)
return arf_set_round(z, x, prec, rnd);
if (k == 2)
return arf_sqrt(z, x, prec, rnd);
if (arf_is_special(x))
{
if (arf_is_neg_inf(x))
arf_nan(z);
else
arf_set(z, x);
return 0;
}
if (ARF_SGNBIT(x))
{
arf_nan(z);
return 0;
}
fmpz_init(q);
fmpz_init(r);
/* x = m * 2^e where e = qk + r */
/* x^(1/k) = (m * 2^(qk+r))^(1/k) */
/* x^(1/k) = (m * 2^r)^(1/k) * 2^q */
fmpz_set_ui(r, k);
fmpz_fdiv_qr(q, r, ARF_EXPREF(x), r);
ARF_GET_MPN_READONLY(xptr, xn, x);
zn = (prec + FLINT_BITS - 1) / FLINT_BITS;
zf->_mpfr_d = tmp = flint_malloc(zn * sizeof(mp_limb_t));
zf->_mpfr_prec = prec;
zf->_mpfr_sign = 1;
zf->_mpfr_exp = 0;
xf->_mpfr_d = (mp_ptr) xptr;
xf->_mpfr_prec = xn * FLINT_BITS;
xf->_mpfr_sign = 1;
xf->_mpfr_exp = fmpz_get_ui(r);
inexact = mpfr_root(zf, xf, k, arf_rnd_to_mpfr(rnd));
inexact = (inexact != 0);
val = 0;
while (tmp[val] == 0)
val++;
ARF_GET_MPN_WRITE(zptr, zn - val, z);
flint_mpn_copyi(zptr, tmp + val, zn - val);
fmpz_add_si(ARF_EXPREF(z), q, zf->_mpfr_exp);
flint_free(tmp);
fmpz_clear(q);
fmpz_clear(r);
return inexact;
}
int
_fmpz_poly_sqrt_classical(fmpz * res, const fmpz * poly, long len)
{
long i, m;
int result;
/* the degree must be even */
if (len % 2 == 0)
return 0;
/* valuation must be even, and then can be reduced to 0 */
while (fmpz_is_zero(poly))
{
if (!fmpz_is_zero(poly + 1))
return 0;
fmpz_zero(res);
poly += 2;
len -= 2;
res++;
}
/* check whether a square root exists modulo 2 */
for (i = 1; i < len; i += 2)
if (!fmpz_is_even(poly + i))
return 0;
/* check endpoints */
if (!fmpz_is_square(poly) || (len > 1 && !fmpz_is_square(poly + len - 1)))
return 0;
/* square root of leading coefficient */
m = (len + 1) / 2;
fmpz_sqrt(res + m - 1, poly + len - 1);
result = 1;
/* do long divison style 'square root with remainder' from top to bottom */
if (len > 1)
{
fmpz_t t, u;
fmpz * r;
fmpz_init(t);
fmpz_init(u);
r = _fmpz_vec_init(len);
_fmpz_vec_set(r, poly, len);
fmpz_mul_ui(u, res + m - 1, 2);
for (i = 1; i < m; i++)
{
fmpz_fdiv_qr(res + m - i - 1, t, r + len - i - 1, u);
if (!fmpz_is_zero(t))
{
result = 0;
break;
}
fmpz_mul_si(t, res + m - i - 1, -2);
_fmpz_vec_scalar_addmul_fmpz(r + len - 2*i, res + m - i, i - 1, t);
fmpz_submul(r + len - 2*i - 1, res + m - i - 1, res + m - i - 1);
}
for (i = m; i < len && result; i++)
if (!fmpz_is_zero(r + len - 1 - i))
result = 0;
_fmpz_vec_clear(r, len);
fmpz_clear(t);
fmpz_clear(u);
}
return result;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("fdiv_qr....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c, r;
mpz_t d, e, f, g, h, s;
slong j;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(r);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
mpz_init(h);
mpz_init(s);
fmpz_randbits(a, state, 1000);
do {
fmpz_randbits(b, state, 500);
} while(fmpz_is_zero(b));
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
for (j = 1; j < 100; j++)
fmpz_fdiv_qr(c, r, a, b);
mpz_fdiv_qr(f, s, d, e);
fmpz_get_mpz(g, c);
fmpz_get_mpz(h, r);
result = (mpz_cmp(f, g) == 0 && mpz_cmp(h, s) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf
("d = %Zd, e = %Zd, f = %Zd, g = %Zd, h = %Zd, s = %Zd\n", d,
e, f, g, h, s);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(r);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
mpz_clear(h);
mpz_clear(s);
}
/* Check aliasing of c and a */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c, r;
mpz_t d, e, f, g, h, s;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(r);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
mpz_init(h);
mpz_init(s);
fmpz_randtest(a, state, 200);
fmpz_randtest_not_zero(b, state, 200);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
fmpz_fdiv_qr(a, r, a, b);
mpz_fdiv_qr(f, s, d, e);
fmpz_get_mpz(g, a);
fmpz_get_mpz(h, r);
result = (mpz_cmp(f, g) == 0 && mpz_cmp(h, s) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf
("d = %Zd, e = %Zd, f = %Zd, g = %Zd, h = %Zd, s = %Zd\n", d,
e, f, g, h, s);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(r);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
mpz_clear(h);
mpz_clear(s);
}
/* Check aliasing of c and b */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c, r;
mpz_t d, e, f, g, h, s;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(r);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
mpz_init(h);
mpz_init(s);
fmpz_randtest(a, state, 200);
fmpz_randtest_not_zero(b, state, 200);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
fmpz_fdiv_qr(b, r, a, b);
mpz_fdiv_qr(f, s, d, e);
fmpz_get_mpz(g, b);
fmpz_get_mpz(h, r);
result = (mpz_cmp(f, g) == 0 && mpz_cmp(h, s) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf
("d = %Zd, e = %Zd, f = %Zd, g = %Zd, h = %Zd, s = %Zd\n", d,
e, f, g, h, s);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(r);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
mpz_clear(h);
mpz_clear(s);
}
/* Check aliasing of r and a */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c, r;
mpz_t d, e, f, g, h, s;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(r);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
mpz_init(h);
mpz_init(s);
fmpz_randtest(a, state, 200);
fmpz_randtest_not_zero(b, state, 200);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
fmpz_fdiv_qr(c, a, a, b);
mpz_fdiv_qr(f, s, d, e);
fmpz_get_mpz(g, c);
fmpz_get_mpz(h, a);
result = (mpz_cmp(f, g) == 0 && mpz_cmp(h, s) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf
("d = %Zd, e = %Zd, f = %Zd, g = %Zd, h = %Zd, s = %Zd\n", d,
e, f, g, h, s);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(r);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
mpz_clear(h);
mpz_clear(s);
}
/* Check aliasing of r and b */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c, r;
mpz_t d, e, f, g, h, s;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(r);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
mpz_init(h);
mpz_init(s);
fmpz_randtest(a, state, 200);
fmpz_randtest_not_zero(b, state, 200);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
fmpz_fdiv_qr(c, b, a, b);
mpz_fdiv_qr(f, s, d, e);
fmpz_get_mpz(g, c);
fmpz_get_mpz(h, b);
result = (mpz_cmp(f, g) == 0 && mpz_cmp(h, s) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf
("d = %Zd, e = %Zd, f = %Zd, g = %Zd, h = %Zd, s = %Zd\n", d,
e, f, g, h, s);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(r);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
mpz_clear(h);
mpz_clear(s);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}