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); }