void
fmpz_comb_clear(fmpz_comb_t comb)
{
long i, j, n;
n = comb->n;
/* Size of top level */
j = (1L << (n - 1));
/* Clear arrays at each level */
for (i = 0; i < n; i++)
{
_fmpz_vec_clear(comb->comb[i], j);
_fmpz_vec_clear(comb->res[i], j);
j /= 2;
}
if (n)
{
free(comb->comb);
free(comb->res);
}
free(comb->mod);
}
void
_fmpz_poly_revert_series_lagrange(fmpz * Qinv, const fmpz * Q, slong n)
{
slong i;
fmpz *R, *S, *T, *tmp;
if (n <= 2)
{
_fmpz_vec_set(Qinv, Q, n);
return;
}
R = _fmpz_vec_init(n - 1);
S = _fmpz_vec_init(n - 1);
T = _fmpz_vec_init(n - 1);
fmpz_zero(Qinv);
fmpz_set(Qinv + 1, Q + 1);
_fmpz_poly_inv_series(R, Q + 1, n - 1);
_fmpz_vec_set(S, R, n - 1);
for (i = 2; i < n; i++)
{
_fmpz_poly_mullow(T, S, n - 1, R, n - 1, n - 1);
fmpz_divexact_ui(Qinv + i, T + i - 1, i);
tmp = S; S = T; T = tmp;
}
_fmpz_vec_clear(R, n - 1);
_fmpz_vec_clear(S, n - 1);
_fmpz_vec_clear(T, n - 1);
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("is_zero....");
fflush(stdout);
flint_randinit(state);
/* Check zero vector */
for (i = 0; i < 10000; i++)
{
fmpz *a;
long len = n_randint(state, 100);
a = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_zero(a, len);
result = (_fmpz_vec_is_zero(a, len));
if (!result)
{
printf("FAIL1:\n");
_fmpz_vec_print(a, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
}
/* Check non-zero vector */
for (i = 0; i < 10000; i++)
{
fmpz *a;
long len = n_randint(state, 100) + 1;
a = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
fmpz_set_ui(a + (len - 1), 1UL);
result = (!_fmpz_vec_is_zero(a, len));
if (!result)
{
printf("FAIL2:\n");
_fmpz_vec_print(a, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_submul_si_2exp....");
fflush(stdout);
/* Compare with alternative method of computation */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b, *c, *d;
slong len = n_randint(state, 100), x;
mp_bitcnt_t exp;
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
d = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
x = z_randtest(state);
exp = n_randint(state, 200);
_fmpz_vec_scalar_submul_si_2exp(b, a, len, x, exp);
_fmpz_vec_scalar_mul_2exp(d, a, len, exp);
_fmpz_vec_scalar_submul_si(c, d, len, x);
result = (_fmpz_vec_equal(b, c, len));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("x = %wd, exp = %wu\n", x, exp);
_fmpz_vec_print(b, len), flint_printf("\n\n");
_fmpz_vec_print(c, len), flint_printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
_fmpz_vec_clear(d, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
fmpz * num1;
fmpz * den1;
fmpz_t num2;
fmpz_t den2;
long n, N;
printf("bernoulli_number....");
fflush(stdout);
N = 4000;
num1 = _fmpz_vec_init(N);
den1 = _fmpz_vec_init(N);
fmpz_init(num2);
fmpz_init(den2);
_bernoulli_number_vec_multi_mod(num1, den1, N);
for (n = 0; n < N; n++)
{
bernoulli_number(num2, den2, n);
if (!fmpz_equal(num1 + n, num2))
{
printf("FAIL: n = %ld, numerator\n", n);
printf("vec: "); fmpz_print(num1 + n); printf("\n");
printf("single: "); fmpz_print(num2); printf("\n");
abort();
}
if (!fmpz_equal(den1 + n, den2))
{
printf("FAIL: n = %ld, denominator\n", n);
printf("vec: "); fmpz_print(den1 + n); printf("\n");
printf("single: "); fmpz_print(den2); printf("\n");
abort();
}
}
_fmpz_vec_clear(num1, N);
_fmpz_vec_clear(den1, N);
fmpz_clear(num2);
fmpz_clear(den2);
mpfr_free_cache();
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void _qadic_exp_balanced(fmpz *rop, const fmpz *x, slong v, slong len,
const fmpz *a, const slong *j, slong lena,
const fmpz_t p, slong N, const fmpz_t pN)
{
const slong d = j[lena - 1];
fmpz_t pw;
fmpz *r, *s, *t;
slong i, w;
r = _fmpz_vec_init(d);
s = _fmpz_vec_init(2*d - 1);
t = _fmpz_vec_init(d);
fmpz_init(pw);
fmpz_pow_ui(pw, p, v);
_fmpz_vec_scalar_mul_fmpz(t, x, len, pw);
_fmpz_vec_scalar_mod_fmpz(t, t, len, pN);
_fmpz_vec_zero(t + len, d - len);
fmpz_set(pw, p);
fmpz_one(rop + 0);
_fmpz_vec_zero(rop + 1, d - 1);
w = 1;
while (!_fmpz_vec_is_zero(t, d))
{
fmpz_mul(pw, pw, pw);
for (i = 0; i < d; i++)
{
fmpz_fdiv_r(r + i, t + i, pw);
fmpz_sub(t + i, t + i, r + i);
}
if (!_fmpz_vec_is_zero(r, d))
{
_qadic_exp_bsplit(r, r, w, d, a, j, lena, p, N);
_fmpz_poly_mul(s, rop, d, r, d);
_fmpz_poly_reduce(s, 2*d - 1, a, j, lena);
_fmpz_vec_scalar_mod_fmpz(rop, s, d, pN);
}
w *= 2;
}
_fmpz_vec_clear(r, d);
_fmpz_vec_clear(s, 2*d - 1);
_fmpz_vec_clear(t, d);
fmpz_clear(pw);
}
int main()
{
fmpz * num1;
fmpz * den1;
fmpz_t num2;
fmpz_t den2;
slong n, N;
flint_printf("fmpq_ui....");
fflush(stdout);
N = 4000;
num1 = _fmpz_vec_init(N);
den1 = _fmpz_vec_init(N);
fmpz_init(num2);
fmpz_init(den2);
_arith_bernoulli_number_vec_multi_mod(num1, den1, N);
for (n = 0; n < N; n++)
{
_bernoulli_fmpq_ui(num2, den2, n);
if (!fmpz_equal(num1 + n, num2))
{
flint_printf("FAIL: n = %wd, numerator\n", n);
flint_printf("vec: "); fmpz_print(num1 + n); flint_printf("\n");
flint_printf("single: "); fmpz_print(num2); flint_printf("\n");
abort();
}
if (!fmpz_equal(den1 + n, den2))
{
flint_printf("FAIL: n = %wd, denominator\n", n);
flint_printf("vec: "); fmpz_print(den1 + n); flint_printf("\n");
flint_printf("single: "); fmpz_print(den2); flint_printf("\n");
abort();
}
}
_fmpz_vec_clear(num1, N);
_fmpz_vec_clear(den1, N);
fmpz_clear(num2);
fmpz_clear(den2);
flint_cleanup();
flint_printf("PASS\n");
return 0;
}
/* Assumes poly1 and poly2 are not length 0 and len1 >= len2. */
void
_fmpz_poly_mul_karatsuba(fmpz * res, const fmpz * poly1,
long len1, const fmpz * poly2, long len2)
{
fmpz *rev1, *rev2, *out, *temp;
long length, loglen = 0;
if (len1 == 1)
{
fmpz_mul(res, poly1, poly2);
return;
}
while ((1L << loglen) < len1)
loglen++;
length = (1L << loglen);
rev1 = (fmpz *) flint_calloc(4 * length, sizeof(fmpz *));
rev2 = rev1 + length;
out = rev1 + 2 * length;
temp = _fmpz_vec_init(2 * length);
revbin1(rev1, poly1, len1, loglen);
revbin1(rev2, poly2, len2, loglen);
_fmpz_poly_mul_kara_recursive(out, rev1, rev2, temp, loglen);
_fmpz_vec_zero(res, len1 + len2 - 1);
revbin2(res, out, len1 + len2 - 1, loglen + 1);
_fmpz_vec_clear(temp, 2 * length);
flint_free(rev1);
}
void
fmpq_mat_mul_fmpz_mat(fmpq_mat_t C, const fmpq_mat_t A, const fmpz_mat_t B)
{
slong i, j;
fmpz_mat_t Aclear;
fmpz_mat_t Cclear;
fmpz * Aden;
fmpz_mat_init(Aclear, A->r, A->c);
fmpz_mat_init(Cclear, A->r, B->c);
Aden = _fmpz_vec_init(A->r);
fmpq_mat_get_fmpz_mat_rowwise(Aclear, Aden, A);
fmpz_mat_mul(Cclear, Aclear, B);
for (i = 0; i < C->r; i++)
{
for (j = 0; j < C->c; j++)
{
fmpz_set(fmpq_mat_entry_num(C, i, j), fmpz_mat_entry(Cclear, i, j));
fmpz_set(fmpq_mat_entry_den(C, i, j), Aden + i);
fmpq_canonicalise(fmpq_mat_entry(C, i, j));
}
}
fmpz_mat_clear(Aclear);
fmpz_mat_clear(Cclear);
_fmpz_vec_clear(Aden, A->r);
}
int _fmpq_poly_is_squarefree(const fmpz * poly, const fmpz_t den, long len)
{
if (len < 3)
return 1;
else if (len == 3)
{
int ans;
fmpz_t lhs, rhs;
fmpz_init(lhs);
fmpz_init(rhs);
fmpz_mul(lhs, poly + 1, poly + 1);
fmpz_mul(rhs, poly, poly + 2);
fmpz_mul_ui(rhs, rhs, 4);
ans = !fmpz_equal(lhs, rhs);
fmpz_clear(lhs);
fmpz_clear(rhs);
return ans;
}
else
{
long gdeg;
fmpz * w = _fmpz_vec_init(2 * len);
_fmpz_poly_derivative(w, poly, len);
_fmpz_poly_gcd(w + len, poly, len, w, len - 1L);
for (gdeg = len - 2L; w[gdeg] == 0L; gdeg--) ;
_fmpz_vec_clear(w, 2 * len);
return (gdeg == 0);
}
}
void partition_function_vec(fmpz * res, long len)
{
fmpz * tmp;
long k, n;
if (len < 1)
return;
tmp = _fmpz_vec_init(len);
tmp[0] = 1L;
for (n = k = 1; n + 4*k + 2 < len; k += 2)
{
tmp[n] = -1L;
tmp[n + k] = -1L;
tmp[n + 3*k + 1] = 1L;
tmp[n + 4*k + 2] = 1L;
n += 6*k + 5;
}
if (n < len) tmp[n] = -1L;
if (n + k < len) tmp[n + k] = -1L;
if (n + 3*k + 1 < len) tmp[n + 3*k + 1] = 1L;
_fmpz_poly_inv_series(res, tmp, len);
_fmpz_vec_clear(tmp, len);
}
void _fmpz_poly_pseudo_div(fmpz * Q, ulong * d, const fmpz * A, long lenA,
const fmpz * B, long lenB)
{
fmpz * R = _fmpz_vec_init(lenA);
_fmpz_poly_pseudo_divrem(Q, R, d, A, lenA, B, lenB);
_fmpz_vec_clear(R, lenA);
}
void _fmpz_poly_hensel_lift_without_inverse(fmpz *G, fmpz *H,
const fmpz *f, long lenF,
const fmpz *g, long lenG, const fmpz *h, long lenH,
const fmpz *a, long lenA, const fmpz *b, long lenB,
const fmpz_t p, const fmpz_t p1)
{
const fmpz one[1] = {1l};
const long lenM = FLINT_MAX(lenG, lenH);
const long lenE = FLINT_MAX(lenG + lenB - 2, lenH + lenA - 2);
const long lenD = FLINT_MAX(lenE, lenF);
fmpz *C, *D, *E, *M;
C = _fmpz_vec_init(lenF + lenD + lenE + lenM);
D = C + lenF;
E = D + lenD;
M = E + lenE;
if (lenG >= lenH)
_fmpz_poly_mul(C, g,lenG, h, lenH);
else
_fmpz_poly_mul(C, h, lenH, g, lenG);
_fmpz_vec_sub(C, f, C, lenF);
_fmpz_vec_scalar_divexact_fmpz(D, C, lenF, p);
_fmpz_vec_scalar_mod_fmpz(C, D, lenF, p1);
lift(G, g, lenG, b, lenB);
lift(H, h, lenH, a, lenA);
_fmpz_vec_clear(C, lenF + lenD + lenE + lenM);
}
void
_fmpq_poly_compose(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1,
long len1, const fmpz * poly2, const fmpz_t den2, long len2)
{
if (*den2 == 1L)
{
_fmpz_poly_compose(res, poly1, len1, poly2, len2);
fmpz_set(den, den1);
_fmpq_poly_canonicalise(res, den, (len1 - 1L) * (len2 - 1L) + 1L);
}
else
{
fmpz_t one;
fmpz * v = _fmpz_vec_init(len1);
fmpz_init(one);
fmpz_one(one);
_fmpq_poly_rescale(v, den, poly1, den1, len1, one, den2);
_fmpz_poly_compose(res, v, len1, poly2, len2);
_fmpq_poly_canonicalise(res, den, (len1 - 1L) * (len2 - 1L) + 1L);
fmpz_clear(one);
_fmpz_vec_clear(v, len1);
}
}
void
_fmpq_poly_compose_series_horner(fmpz * res, fmpz_t den, const fmpz * poly1,
const fmpz_t den1, long len1, const fmpz * poly2,
const fmpz_t den2, long len2, long n)
{
if (fmpz_is_one(den2))
{
_fmpz_poly_compose_series(res, poly1, len1, poly2, len2, n);
fmpz_set(den, den1);
_fmpq_poly_canonicalise(res, den, n);
}
else if (n == 1)
{
fmpz_set(res, poly1);
fmpz_set(den, den1);
_fmpq_poly_canonicalise(res, den, 1);
}
else
{
long i = len1 - 1;
long lenr;
fmpz_t tden;
fmpz * t = _fmpz_vec_init(n);
fmpz_init(tden);
_fmpz_vec_zero(res, n);
lenr = len2;
_fmpq_poly_scalar_mul_fmpz(res, den, poly2, den2, len2, poly1 + i);
_fmpq_poly_scalar_div_fmpz(res, den, res, den, len2, den1);
i--;
_fmpq_poly_add(res, den, res, den, len2, poly1 + i, den1, 1);
_fmpq_poly_canonicalise(res, den, lenr);
while (i > 0)
{
i--;
if (lenr + len2 - 1 < n)
{
_fmpq_poly_mul(t, tden, res, den, lenr, poly2, den2, len2);
lenr = lenr + len2 - 1;
}
else
{
_fmpq_poly_mullow(t, tden, res, den, lenr,
poly2, den2, len2, n);
lenr = n;
}
_fmpq_poly_canonicalise(t, tden, lenr);
_fmpq_poly_add(res, den, t, tden, lenr, poly1 + i, den1, 1);
}
_fmpq_poly_canonicalise(res, den, n);
_fmpz_vec_clear(t, n);
fmpz_clear(tden);
}
}
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;
}
void
_fmpz_poly_revert_series_newton(fmpz * Qinv, const fmpz * Q, long n)
{
if (n <= 2)
{
_fmpz_vec_set(Qinv, Q, n);
return;
}
else
{
long *a, i, k;
fmpz *T, *U, *V;
T = _fmpz_vec_init(n);
U = _fmpz_vec_init(n);
V = _fmpz_vec_init(n);
k = n;
for (i = 1; (1L << i) < k; i++);
a = (long *) flint_malloc(i * sizeof(long));
a[i = 0] = k;
while (k >= FLINT_REVERSE_NEWTON_CUTOFF)
a[++i] = (k = (k + 1) / 2);
_fmpz_poly_revert_series_lagrange(Qinv, Q, k);
_fmpz_vec_zero(Qinv + k, n - k);
for (i--; i >= 0; i--)
{
k = a[i];
_fmpz_poly_compose_series(T, Q, k, Qinv, k, k);
_fmpz_poly_derivative(U, T, k); fmpz_zero(U + k - 1);
fmpz_zero(T + 1);
_fmpz_poly_div_series(V, T, U, k);
_fmpz_poly_derivative(T, Qinv, k);
_fmpz_poly_mullow(U, V, k, T, k, k);
_fmpz_vec_sub(Qinv, Qinv, U, k);
}
flint_free(a);
_fmpz_vec_clear(T, n);
_fmpz_vec_clear(U, n);
_fmpz_vec_clear(V, n);
}
}
void
fmpz_mat_randntrulike(fmpz_mat_t mat, flint_rand_t state, mp_bitcnt_t bits, ulong q)
{
long r, c, d, i, j, k;
fmpz *h;
r = mat->r;
c = mat->c;
d = r / 2;
if ((c != r) || (c != 2 * d))
{
printf
("Exception: fmpz_mat_randntrulike called on an ill-formed matrix\n");
abort();
}
h = _fmpz_vec_init(d);
for (i = 0; i < d; i++)
fmpz_randbits(h + i, state, bits);
for (i = 0; i < d; i++)
{
for (j = 0; j < i; j++)
fmpz_zero(mat->rows[i] + j);
fmpz_one(mat->rows[i] + i);
for (j = i + 1; j < d; j++)
fmpz_zero(mat->rows[i] + j);
}
for (i = d; i < r; i++)
for (j = 0; j < d; j++)
fmpz_zero(mat->rows[i] + j);
for (i = d; i < r; i++)
{
for (j = d; j < i; j++)
fmpz_zero(mat->rows[i] + j);
fmpz_set_ui(mat->rows[i] + i, q);
for (j = i + 1; j < c; j++)
fmpz_zero(mat->rows[i] + j);
}
for (i = 0; i < d; i++)
{
for (j = d; j < c; j++)
{
k = j + i;
while (k >= d)
k -= d;
fmpz_set(mat->rows[i] + j, h + k);
}
}
_fmpz_vec_clear(h, d);
}
void
_fmpz_poly_powers_clear(fmpz ** powers, slong len)
{
slong i;
for (i = 0; i < 2*len - 1; i++)
_fmpz_vec_clear(powers[i], len - 1);
flint_free(powers);
}
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;
}
void
_fmpq_poly_invsqrt_series(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, long n)
{
long m;
fmpz * t, * u;
fmpz_t tden, uden;
if (n == 1)
{
fmpz_one(rpoly);
fmpz_one(rden);
return;
}
m = (n + 1) / 2;
_fmpq_poly_invsqrt_series(rpoly, rden, poly, den, m);
fmpz_init(tden);
fmpz_init(uden);
t = _fmpz_vec_init(n);
u = _fmpz_vec_init(n);
_fmpz_vec_zero(rpoly + m, n - m);
_fmpq_poly_mul(t, tden, rpoly, rden, m, rpoly, rden, m);
if (2*m - 1 < n)
fmpz_zero(t + n - 1);
_fmpq_poly_mullow(u, uden, t, tden, n, rpoly, rden, n, n);
_fmpq_poly_mullow(t, tden, u, uden, n, poly, den, n, n);
_fmpz_vec_neg(t + m, t + m, n - m);
_fmpz_vec_zero(t, m);
fmpz_mul_ui(tden, tden, 2UL);
_fmpq_poly_canonicalise(t, tden, n);
_fmpq_poly_add(rpoly, rden, rpoly, rden, m, t, tden, n);
fmpz_clear(tden);
fmpz_clear(uden);
_fmpz_vec_clear(t, n);
_fmpz_vec_clear(u, n);
}
static void
_qadic_exp_bsplit(fmpz *y, const fmpz *x, slong v, slong len,
const fmpz *a, const slong *j, slong lena,
const fmpz_t p, slong N)
{
const slong d = j[lena - 1];
const slong n = _padic_exp_bound(v, N, p);
if (n == 1)
{
fmpz_one(y + 0);
_fmpz_vec_zero(y + 1, d - 1);
}
else
{
fmpz *P, *T;
fmpz_t Q, R;
slong f;
P = _fmpz_vec_init(2*d - 1);
T = _fmpz_vec_init(2*d - 1);
fmpz_init(Q);
fmpz_init(R);
_qadic_exp_bsplit_series(P, Q, T, x, len, 1, n, a, j, lena);
fmpz_add(T + 0, T + 0, Q); /* (T,Q) := (T,Q) + 1 */
/* Note exp(x) is a unit so val(T) == val(Q). */
f = fmpz_remove(Q, Q, p);
fmpz_pow_ui(R, p, f);
_fmpz_vec_scalar_divexact_fmpz(T, T, d, R);
_padic_inv(Q, Q, p, N);
_fmpz_vec_scalar_mul_fmpz(y, T, d, Q);
_fmpz_vec_clear(P, 2*d - 1);
_fmpz_vec_clear(T, 2*d - 1);
fmpz_clear(Q);
fmpz_clear(R);
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("prod....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz *a, *b;
fmpz_t x, y, z;
long len1 = n_randint(state, 100);
long len2 = n_randint(state, 100);
a = _fmpz_vec_init(len1 + len2);
b = a + len1;
_fmpz_vec_randtest(a, state, len1 + len2, 200);
fmpz_init(x);
fmpz_init(y);
fmpz_init(z);
_fmpz_vec_prod(x, a, len1);
_fmpz_vec_prod(y, b, len2);
fmpz_mul(x, x, y);
_fmpz_vec_prod(z, a, len1 + len2);
result = (fmpz_equal(x, z));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(a, len1), printf("\n\n");
_fmpz_vec_print(b, len2), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len1 + len2);
fmpz_clear(x);
fmpz_clear(y);
fmpz_clear(z);
}
flint_randclear(state);
_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 renf_randtest(renf_t nf, flint_rand_t state, slong len, slong prec, mp_bitcnt_t bits)
{
fmpz_poly_t p;
fmpq_poly_t p2;
fmpz * c_array;
slong * k_array;
slong n_interval, n_exact;
ulong i;
arb_t emb;
/* compute a random irreducible polynomial */
if (len <= 1)
{
fprintf(stderr, "ERROR (renf_randtest): got length < 2\n");
abort();
}
fmpz_poly_init(p);
do{
fmpz_poly_randtest_irreducible(p, state, len, bits);
}while(!fmpz_poly_has_real_root(p));
/* pick a random real root */
c_array = _fmpz_vec_init(p->length);
k_array = malloc((p->length) * sizeof(slong));
n_interval = 0;
fmpz_poly_isolate_real_roots(NULL, &n_exact,
c_array, k_array, &n_interval, p);
if (n_interval == 0)
{
fprintf(stderr, "Runtime error\n");
abort();
}
i = n_randint(state, n_interval);
/* construct the associated number field */
arb_init(emb);
arb_from_interval(emb, c_array+i, k_array[i], fmpz_bits(c_array + i) + FLINT_MAX(k_array[i], 0) + 2);
fmpq_poly_init(p2);
fmpq_poly_set_fmpz_poly(p2, p);
/* NOTE: renf init might not be happy with the ball emb */
renf_init(nf, p2, emb, prec);
_fmpz_vec_clear(c_array, p->length);
free(k_array);
fmpz_poly_clear(p);
fmpq_poly_clear(p2);
arb_clear(emb);
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("cfrac_bound....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x, r;
fmpz * c;
slong n, bound;
fmpq_init(x);
fmpq_init(r);
/* Test worst case (quotient of Fibonacci numbers) */
if (n_randint(state, 50) == 1)
{
slong v = 1 + n_randint(state, 1000);
fmpz_fib_ui(fmpq_numref(x), v + 1);
fmpz_fib_ui(fmpq_denref(x), v);
}
else
{
fmpq_randtest(x, state, 1 + n_randint(state, 1000));
}
bound = fmpq_cfrac_bound(x);
c = _fmpz_vec_init(bound + 10);
n = fmpq_get_cfrac(c, r, x, bound);
if (n > bound)
{
flint_printf("FAIL: length=%wd > bound=%wd\n", n, bound);
abort();
}
_fmpz_vec_clear(c, bound + 10);
fmpq_clear(x);
fmpq_clear(r);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
/*
Applies the operator $\sigma^e$ to all elements in the matrix \code{op},
setting the corresponding elements in \code{rop} to the results.
*/
static
void fmpz_poly_mat_frobenius(fmpz_poly_mat_t B,
const fmpz_poly_mat_t A, long e,
const fmpz_t p, long N, const qadic_ctx_t ctx)
{
const long d = qadic_ctx_degree(ctx);
e = e % d;
if (e < 0)
e += d;
if (e == 0)
{
fmpz_t pN;
fmpz_init(pN);
fmpz_pow_ui(pN, p, N);
fmpz_poly_mat_scalar_mod_fmpz(B, A, pN);
fmpz_clear(pN);
}
else
{
long i, j;
fmpz *t = _fmpz_vec_init(2 * d - 1);
for (i = 0; i < B->r; i++)
for (j = 0; j < B->c; j++)
{
const fmpz_poly_struct *a = fmpz_poly_mat_entry(A, i, j);
fmpz_poly_struct *b = fmpz_poly_mat_entry(B, i, j);
if (a->length == 0)
{
fmpz_poly_zero(b);
}
else
{
_qadic_frobenius(t, a->coeffs, a->length, e,
ctx->a, ctx->j, ctx->len, p, N);
fmpz_poly_fit_length(b, d);
_fmpz_vec_set(b->coeffs, t, d);
_fmpz_poly_set_length(b, d);
_fmpz_poly_normalise(b);
}
}
_fmpz_vec_clear(t, 2 * d - 1);
}
}
void
_fmpq_poly_sqrt_series(fmpz * rpoly, fmpz_t rden,
const fmpz * poly, const fmpz_t den, slong n)
{
fmpz * t;
fmpz_t tden;
t = _fmpz_vec_init(n);
fmpz_init(tden);
_fmpq_poly_invsqrt_series(t, tden, poly, den, n);
_fmpq_poly_mullow(rpoly, rden, t, tden, n, poly, den, n, n);
_fmpz_vec_clear(t, n);
fmpz_clear(tden);
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("content....");
fflush(stdout);
/* Check that content(a f) = abs(a) content(f) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a, c, d;
fmpz *f;
slong len = n_randint(state, 100);
fmpz_init(a);
fmpz_init(c);
fmpz_init(d);
f = _fmpz_vec_init(len);
_fmpz_vec_randtest(f, state, len, 200);
fmpz_randtest(a, state, 100);
_fmpz_vec_content(c, f, len);
_fmpz_vec_scalar_mul_fmpz(f, f, len, a);
fmpz_abs(a, a);
fmpz_mul(c, a, c);
_fmpz_vec_content(d, f, len);
result = (fmpz_equal(c, d));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(c), flint_printf("\n\n");
fmpz_print(d), flint_printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(c);
fmpz_clear(d);
_fmpz_vec_clear(f, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void _fmpq_poly_log_series(fmpz * g, fmpz_t gden,
const fmpz * f, const fmpz_t fden, long n)
{
fmpz * f_diff;
fmpz * f_inv;
fmpz_t f_diff_den;
fmpz_t f_inv_den;
f_diff = _fmpz_vec_init(n);
f_inv = _fmpz_vec_init(n);
fmpz_init(f_diff_den);
fmpz_init(f_inv_den);
_fmpq_poly_derivative(f_diff, f_diff_den, f, fden, n);
_fmpq_poly_inv_series(f_inv, f_inv_den, f, fden, n);
_fmpq_poly_mullow(g, gden, f_diff, f_diff_den, n - 1, f_inv, f_inv_den, n - 1, n - 1);
_fmpq_poly_integral(g, gden, g, gden, n);
_fmpz_vec_clear(f_diff, n);
_fmpz_vec_clear(f_inv, n);
fmpz_clear(f_diff_den);
fmpz_clear(f_inv_den);
}
