int main() { slong iter; flint_rand_t state; flint_printf("cmpabs...."); fflush(stdout); flint_randinit(state); /* compare with fmpz */ { arf_t x, y; fmpz_t X, Y; arf_init(x); arf_init(y); fmpz_init(X); fmpz_init(Y); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { int cmp1, cmp2; fmpz_randtest(X, state, 1 + n_randint(state, 1000)); switch (n_randint(state, 8)) { case 0: fmpz_neg(Y, X); break; case 1: fmpz_set(Y, X); break; default: fmpz_randtest(Y, state, 1 + n_randint(state, 1000)); } arf_set_fmpz(x, X); arf_set_fmpz(y, Y); cmp1 = arf_cmpabs(x, y); cmp2 = fmpz_cmpabs(X, Y); cmp2 = (cmp2 > 0) - (cmp2 < 0); if (cmp1 != cmp2) { flint_printf("FAIL\n\n"); flint_printf("x = "); arf_debug(x); flint_printf("\n\n"); flint_printf("y = "); arf_debug(y); flint_printf("\n\n"); flint_printf("X = "); fmpz_print(X); flint_printf("\n\n"); flint_printf("Y = "); fmpz_print(Y); flint_printf("\n\n"); flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2); abort(); } } arf_clear(x); arf_clear(y); fmpz_clear(X); fmpz_clear(Y); } /* compare with mpfr */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { slong bits; arf_t x, y; mpfr_t X, Y; int cmp1, cmp2; bits = 2 + n_randint(state, 200); arf_init(x); arf_init(y); mpfr_init2(X, bits); mpfr_init2(Y, bits); arf_randtest_special(x, state, bits, 10); arf_randtest_special(y, state, bits, 10); arf_get_mpfr(X, x, MPFR_RNDN); arf_get_mpfr(Y, y, MPFR_RNDN); mpfr_abs(X, X, MPFR_RNDN); mpfr_abs(Y, Y, MPFR_RNDN); cmp1 = arf_cmpabs(x, y); cmp2 = mpfr_cmp(X, Y); if (cmp1 != cmp2) { flint_printf("FAIL\n\n"); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); arf_print(y); flint_printf("\n\n"); flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2); abort(); } arf_clear(x); arf_clear(y); mpfr_clear(X); mpfr_clear(Y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void _fmpq_poly_revert_series_lagrange(fmpz * Qinv, fmpz_t den, const fmpz * Q, const fmpz_t Qden, long n) { long i; fmpz *R, *S, *T, *dens, *tmp; fmpz_t Rden, Sden, Tden; if (fmpz_is_one(Qden) && (n > 1) && fmpz_is_pm1(Q + 1)) { _fmpz_poly_revert_series(Qinv, Q, n); fmpz_one(den); } else if (n <= 2) { fmpz_zero(Qinv); if (n == 2) { fmpz_set(Qinv + 1, Qden); fmpz_set(den, Q + 1); _fmpq_poly_canonicalise(Qinv, den, 2); } } else { dens = _fmpz_vec_init(n); R = _fmpz_vec_init(n - 1); S = _fmpz_vec_init(n - 1); T = _fmpz_vec_init(n - 1); fmpz_init(Rden); fmpz_init(Sden); fmpz_init(Tden); fmpz_zero(Qinv); fmpz_one(dens); fmpz_set(Qinv + 1, Qden); fmpz_set(dens + 1, Q + 1); _fmpq_poly_inv_series(R, Rden, Q + 1, Qden, n - 1); _fmpq_poly_canonicalise(R, Rden, n - 1); _fmpz_vec_set(S, R, n - 1); fmpz_set(Sden, Rden); for (i = 2; i < n; i++) { _fmpq_poly_mullow(T, Tden, S, Sden, n - 1, R, Rden, n - 1, n - 1); _fmpq_poly_canonicalise(T, Tden, n - 1); fmpz_set(Qinv + i, T + i - 1); fmpz_mul_ui(dens + i, Tden, i); tmp = S; S = T; T = tmp; fmpz_swap(Sden, Tden); } _set_vec(Qinv, den, Qinv, dens, n); _fmpq_poly_canonicalise(Qinv, den, n); _fmpz_vec_clear(R, n - 1); _fmpz_vec_clear(S, n - 1); _fmpz_vec_clear(T, n - 1); _fmpz_vec_clear(dens, n); fmpz_clear(Rden); fmpz_clear(Sden); fmpz_clear(Tden); } }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("evaluate_fmpz...."); fflush(stdout); /* Check that (f+g)(a) = f(a) + g(a) */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a; fmpq_poly_t f, g, h; fmpq_t x, y; fmpq_init(x); fmpq_init(y); fmpz_init(a); fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(h); fmpq_poly_randtest(f, state, n_randint(state, 100), 200); fmpq_poly_randtest(g, state, n_randint(state, 100), 200); fmpz_randtest(a, state, n_randint(state, 100)); fmpq_poly_evaluate_fmpz(x, f, a); fmpq_poly_evaluate_fmpz(y, g, a); fmpq_add(x, x, y); fmpq_poly_add(h, f, g); fmpq_poly_evaluate_fmpz(y, h, a); result = (fmpq_equal(x, y)); if (!result) { flint_printf("FAIL:\n"); flint_printf("f = "), fmpq_poly_debug(f), flint_printf("\n"); flint_printf("g = "), fmpq_poly_debug(g), flint_printf("\n"); flint_printf("a = "), fmpz_print(a), flint_printf("\n"); flint_printf("f(a) + g(a) = "), fmpq_print(x), flint_printf("\n\n"); flint_printf("(f + g)(a) = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpz_clear(a); fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); } /* Check that (f*g)(a) = f(a) * g(a) */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a; fmpq_poly_t f, g; fmpq_t x, y; fmpq_init(x); fmpq_init(y); fmpz_init(a); fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_randtest(f, state, n_randint(state, 100), 200); fmpq_poly_randtest(g, state, n_randint(state, 100), 200); fmpz_randtest(a, state, n_randint(state, 100)); fmpq_poly_evaluate_fmpz(x, f, a); fmpq_poly_evaluate_fmpz(y, g, a); fmpq_mul(x, x, y); fmpq_poly_mul(f, f, g); fmpq_poly_evaluate_fmpz(y, f, a); result = (fmpq_equal(x, y)); if (!result) { flint_printf("FAIL:\n"); fmpz_print(a), flint_printf("\n\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpz_clear(a); fmpq_poly_clear(f); fmpq_poly_clear(g); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
char * _padic_get_str(char * str, const padic_t op, const padic_ctx_t ctx) { const fmpz * u = padic_unit(op); const long v = padic_val(op); if (fmpz_is_zero(u)) { if (!str) { str = flint_malloc(2); } str[0] = '0'; str[1] = '\0'; return str; } if (ctx->mode == PADIC_TERSE) { if (v == 0) { str = fmpz_get_str(str, 10, u); } else if (v > 0) { fmpz_t t; fmpz_init(t); fmpz_pow_ui(t, ctx->p, v); fmpz_mul(t, t, u); str = fmpz_get_str(str, 10, t); fmpz_clear(t); } else /* v < 0 */ { fmpz_t t; fmpz_init(t); fmpz_pow_ui(t, ctx->p, -v); str = _fmpq_get_str(str, 10, u, t); fmpz_clear(t); } } else if (ctx->mode == PADIC_SERIES) { char *s; fmpz_t x; fmpz_t d; long j, N; if (fmpz_sgn(u) < 0) { printf("ERROR (_padic_get_str). u < 0 in SERIES mode.\n"); abort(); } N = fmpz_clog(u, ctx->p) + v; if (!str) { long b = (N - v) * (2 * fmpz_sizeinbase(ctx->p, 10) + z_sizeinbase(FLINT_MAX(FLINT_ABS(v), FLINT_ABS(N)), 10) + 5) + 1; str = flint_malloc(b); if (!str) { printf("ERROR (_padic_get_str). Memory allocation failed.\n"); abort(); } } s = str; fmpz_init(d); fmpz_init(x); fmpz_set(x, u); /* Unroll first step */ j = 0; { fmpz_mod(d, x, ctx->p); /* d = u mod p^{j+1} */ fmpz_sub(x, x, d); /* x = x - d */ fmpz_divexact(x, x, ctx->p); /* x = x / p */ if (!fmpz_is_zero(d)) { if (j + v != 0) { fmpz_get_str(s, 10, d); while (*++s != '\0') ; *s++ = '*'; fmpz_get_str(s, 10, ctx->p); while (*++s != '\0') ; *s++ = '^'; sprintf(s, "%ld", j + v); while (*++s != '\0') ; } else { fmpz_get_str(s, 10, d); while (*++s != '\0') ; } } j++; } for ( ; !fmpz_is_zero(x); j++) { fmpz_mod(d, x, ctx->p); /* d = u mod p^{j+1} */ fmpz_sub(x, x, d); /* x = x - d */ fmpz_divexact(x, x, ctx->p); /* x = x / p */ if (!fmpz_is_zero(d)) { if (j + v != 0) { *s++ = ' '; *s++ = '+'; *s++ = ' '; fmpz_get_str(s, 10, d); while (*++s != '\0') ; *s++ = '*'; fmpz_get_str(s, 10, ctx->p); while (*++s != '\0') ; *s++ = '^'; sprintf(s, "%ld", j + v); while (*++s != '\0') ; } else { *s++ = ' '; *s++ = '+'; *s++ = ' '; fmpz_get_str(s, 10, d); while (*++s != '\0') ; } } } fmpz_clear(x); fmpz_clear(d); } else /* ctx->mode == PADIC_VAL_UNIT */ { if (!str) { long b = fmpz_sizeinbase(u, 10) + fmpz_sizeinbase(ctx->p, 10) + z_sizeinbase(v, 10) + 4; str = flint_malloc(b); if (!str) { printf("ERROR (_padic_get_str). Memory allocation failed.\n"); abort(); } } if (v == 0) { str = fmpz_get_str(str, 10, u); } else if (v == 1) { char *s = str; fmpz_get_str(s, 10, u); while (*++s != '\0') ; *s++ = '*'; fmpz_get_str(s, 10, ctx->p); } else { char *s = str; fmpz_get_str(s, 10, u); while (*++s != '\0') ; *s++ = '*'; fmpz_get_str(s, 10, ctx->p); while (*++s != '\0') ; *s++ = '^'; sprintf(s, "%ld", v); } } return str; }
int main() { slong n = 7; fmpz_t mod; fmpz* xs = _fmpz_vec_init(n); fmpz* ys = _fmpz_vec_init(n); fmpz_mod_poly_t res; fmpz_poly_t res2; fmpz_init(mod); fmpz_set_ui(mod, 11); fmpz_set_ui(xs, 0); fmpz_set_ui(xs+1, 1); fmpz_set_ui(xs+2, 2); fmpz_set_ui(xs+3, 3); fmpz_set_ui(xs+4, 4); fmpz_set_ui(xs+5, 5); fmpz_set_ui(xs+6, 6); fmpz_set_si(ys, 5); fmpz_set_si(ys+1, 1); fmpz_set_si(ys+2, 4); fmpz_set_si(ys+3, 8); fmpz_set_si(ys+4, 4); fmpz_set_si(ys+5, 1); fmpz_set_si(ys+6, 5); printf("xs :\n"); _fmpz_vec_print(xs,n); printf("\n"); printf("ys :\n"); _fmpz_vec_print(ys,n); printf("\n"); fmpz_mod_poly_init(res,mod); fmpz_mod_poly_interpolate_fmpz_vec_fast(res, xs, ys, n, mod); fmpz_poly_init(res2); fmpz_poly_interpolate_fmpz_vec(res2, xs, ys, n); printf("Nouvelle interpolation (f(xs) = ys) :\n"); fmpz_mod_poly_print(res); printf("\n"); fmpz* zs = _fmpz_vec_init(n); fmpz_poly_evaluate_fmpz_vec(zs, res2, xs, n); fmpz* as = _fmpz_vec_init(n); fmpz_mod_poly_evaluate_fmpz_vec(as, res, xs, n); printf("f(xs) :\n"); _fmpz_vec_print(as,n); printf("\n"); printf("FLINT :\n"); fmpz_poly_print(res2); printf("\n"); printf("f(xs) :\n"); _fmpz_vec_print(zs,n); printf("\n"); fmpz_clear(mod); _fmpz_vec_clear(xs,n); _fmpz_vec_clear(ys,n); return 0; }
int main(int argc, char *argv[]) { slong i, len, prec, num_threads; char * out_file; arb_ptr z; if (argc < 2) { flint_printf("keiper_li n [-prec prec] [-threads num_threads] [-out out_file]\n"); return 1; } len = atol(argv[1]) + 1; prec = 1.1 * len + 50; num_threads = 1; out_file = NULL; for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-prec")) prec = atol(argv[i+1]); else if (!strcmp(argv[i], "-threads")) num_threads = atol(argv[i+1]); else if (!strcmp(argv[i], "-out")) out_file = argv[i+1]; } flint_set_num_threads(num_threads); z = _arb_vec_init(len); keiper_li_series(z, len, prec); for (i = 0; i < len; i++) { if (i <= 10 || len - i <= 10) { flint_printf("%wd: ", i); arb_printd(z + i, 50); flint_printf("\n"); } } SHOW_MEMORY_USAGE if (out_file != NULL) { fmpz_t man, exp; arf_t t; FILE * fp = fopen(out_file, "w"); fmpz_init(man); fmpz_init(exp); arf_init(t); for (i = 0; i < len; i++) { arf_get_fmpz_2exp(man, exp, arb_midref(z + i)); flint_fprintf(fp, "%wd ", i); fmpz_fprint(fp, man); flint_fprintf(fp, " "); fmpz_fprint(fp, exp); flint_fprintf(fp, " "); arf_set_mag(t, arb_radref(z + i)); arf_get_fmpz_2exp(man, exp, t); fmpz_fprint(fp, man); flint_fprintf(fp, " "); fmpz_fprint(fp, exp); flint_fprintf(fp, "\n"); } fclose(fp); fmpz_clear(man); fmpz_clear(exp); arf_clear(t); } _arb_vec_clear(z, len); flint_cleanup(); return 0; }
int arf_submul_mpz(arf_ptr z, arf_srcptr x, const mpz_t y, slong prec, arf_rnd_t rnd) { mp_size_t xn, yn, zn, tn, alloc; mp_srcptr xptr, yptr, zptr; mp_ptr tptr, tptr2; fmpz_t texp, yexp; slong shift; int tsgnbit, ysgnbit, inexact; ARF_MUL_TMP_DECL yn = FLINT_ABS(y->_mp_size); if (arf_is_special(x) || yn == 0 || arf_is_special(z)) { if (arf_is_zero(z)) { /* TODO: make more efficient */ arf_mul_mpz(z, x, y, ARF_PREC_EXACT, rnd); return arf_neg_round(z, z, prec, rnd); } else if (arf_is_finite(x)) { return arf_set_round(z, z, prec, rnd); } else { /* todo: speed up */ arf_t t; arf_init(t); arf_mul_mpz(t, x, y, ARF_PREC_EXACT, ARF_RND_DOWN); inexact = arf_sub(z, z, t, prec, rnd); arf_clear(t); return inexact; } } ARF_GET_MPN_READONLY(xptr, xn, x); yptr = y->_mp_d; ysgnbit = (y->_mp_size > 0); *yexp = yn * FLINT_BITS; ARF_GET_MPN_READONLY(zptr, zn, z); fmpz_init(texp); tsgnbit = ARF_SGNBIT(x) ^ ysgnbit; alloc = tn = xn + yn; ARF_MUL_TMP_ALLOC(tptr2, alloc) tptr = tptr2; ARF_MPN_MUL(tptr, xptr, xn, yptr, yn); shift = (tptr[tn - 1] == 0) * FLINT_BITS; tn -= (tptr[tn - 1] == 0); _fmpz_add2_fast(texp, ARF_EXPREF(x), yexp, -shift); shift = _fmpz_sub_small(ARF_EXPREF(z), texp); if (shift >= 0) inexact = _arf_add_mpn(z, zptr, zn, ARF_SGNBIT(z), ARF_EXPREF(z), tptr, tn, tsgnbit, shift, prec, rnd); else inexact = _arf_add_mpn(z, tptr, tn, tsgnbit, texp, zptr, zn, ARF_SGNBIT(z), -shift, prec, rnd); ARF_MUL_TMP_FREE(tptr2, alloc) fmpz_clear(texp); return inexact; }
int main() { long iter; flint_rand_t state; printf("get_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { long bits; fmpr_t x; mpfr_t y; fmpz_t z, z2; mpz_t w; bits = 2 + n_randint(state, 1000); fmpr_init(x); mpfr_init2(y, bits); fmpz_init(z); fmpz_init(z2); mpz_init(w); fmpr_randtest(x, state, bits, 10); fmpr_get_mpfr(y, x, MPFR_RNDN); switch (n_randint(state, 5)) { case 0: fmpr_get_fmpz(z, x, FMPR_RND_FLOOR); mpfr_get_z(w, y, MPFR_RNDD); break; case 1: fmpr_get_fmpz(z, x, FMPR_RND_CEIL); mpfr_get_z(w, y, MPFR_RNDU); break; case 2: fmpr_get_fmpz(z, x, FMPR_RND_DOWN); mpfr_get_z(w, y, MPFR_RNDZ); break; case 3: fmpr_get_fmpz(z, x, FMPR_RND_UP); mpfr_get_z(w, y, MPFR_RNDA); break; default: fmpr_get_fmpz(z, x, FMPR_RND_NEAR); mpfr_get_z(w, y, MPFR_RNDN); break; } fmpz_set_mpz(z2, w); if (!fmpz_equal(z, z2)) { printf("FAIL\n\n"); printf("x = "); fmpr_print(x); printf("\n\n"); printf("z = "); fmpz_print(z); printf("\n\n"); printf("z2 = "); fmpz_print(z2); printf("\n\n"); abort(); } fmpr_clear(x); mpfr_clear(y); fmpz_clear(z); fmpz_clear(z2); mpz_clear(w); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("add_inline...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { fmpz_t a, b, c, d; fmpz_init(a); fmpz_init(b); fmpz_init(c); fmpz_init(d); fmpz_randtest(a, state, 1 + n_randint(state, 200)); fmpz_randtest(b, state, 1 + n_randint(state, 200)); fmpz_randtest(c, state, 1 + n_randint(state, 200)); fmpz_randtest(d, state, 1 + n_randint(state, 200)); fmpz_add(c, a, b); fmpz_add_inline(d, a, b); if (!fmpz_equal(c, d)) { flint_printf("FAIL\n"); fmpz_print(a); flint_printf("\n\n"); fmpz_print(b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_add_inline(a, a, b); if (!fmpz_equal(c, a)) { flint_printf("FAIL (aliasing 1)\n"); fmpz_print(a); flint_printf("\n\n"); fmpz_print(b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_randtest(a, state, 1 + n_randint(state, 200)); fmpz_add(c, a, b); fmpz_add_inline(b, a, b); if (!fmpz_equal(c, b)) { flint_printf("FAIL (aliasing 2)\n"); fmpz_print(a); flint_printf("\n\n"); fmpz_print(b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_add(d, a, a); fmpz_add_inline(c, a, a); if (!fmpz_equal(c, d)) { flint_printf("FAIL (aliasing 3)\n"); fmpz_print(a); flint_printf("\n\n"); fmpz_print(b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_add(d, a, a); fmpz_add_inline(a, a, a); if (!fmpz_equal(d, a)) { flint_printf("FAIL (aliasing 4)\n"); fmpz_print(a); flint_printf("\n\n"); fmpz_print(b); flint_printf("\n\n"); fmpz_print(c); flint_printf("\n\n"); fmpz_print(d); flint_printf("\n\n"); abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); fmpz_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void fmpq_poly_compose_series_horner(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, long n) { long len1 = poly1->length; long len2 = poly2->length; long lenr; if (len2 != 0 && !fmpz_is_zero(poly2->coeffs)) { printf("exception: fmpq_poly_compose_series_horner: inner polynomial " "must have zero constant term\n"); abort(); } if (len1 == 0 || n == 0) { fmpq_poly_zero(res); return; } if (len2 == 0 || len1 == 1) { fmpq_poly_fit_length(res, 1); fmpz_set(res->coeffs, poly1->coeffs); fmpz_set(res->den, poly1->den); { fmpz_t d; fmpz_init(d); fmpz_gcd(d, res->coeffs, res->den); if (!fmpz_is_one(d)) { fmpz_divexact(res->coeffs, res->coeffs, d); fmpz_divexact(res->den, res->den, d); } fmpz_clear(d); } _fmpq_poly_set_length(res, 1); _fmpq_poly_normalise(res); return; } lenr = FLINT_MIN((len1 - 1) * (len2 - 1) + 1, n); len1 = FLINT_MIN(len1, lenr); len2 = FLINT_MIN(len2, lenr); if ((res != poly1) && (res != poly2)) { fmpq_poly_fit_length(res, lenr); _fmpq_poly_compose_series_horner(res->coeffs, res->den, poly1->coeffs, poly1->den, len1, poly2->coeffs, poly2->den, len2, lenr); _fmpq_poly_set_length(res, lenr); _fmpq_poly_normalise(res); } else { fmpq_poly_t t; fmpq_poly_init2(t, lenr); _fmpq_poly_compose_series_horner(t->coeffs, t->den, poly1->coeffs, poly1->den, len1, poly2->coeffs, poly2->den, len2, lenr); _fmpq_poly_set_length(t, lenr); _fmpq_poly_normalise(t); fmpq_poly_swap(res, t); fmpq_poly_clear(t); } }
int main(void) { fmpz_mat_t A, X, B, AX; fmpz_t den; slong i, m, n, r; int success; FLINT_TEST_INIT(state); flint_printf("solve_cramer...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { m = n_randint(state, 4); n = n_randint(state, 10); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(X, m, n); fmpz_mat_init(AX, m, n); fmpz_init(den); fmpz_mat_randrank(A, state, m, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); success = fmpz_mat_solve_cramer(X, den, A, B); fmpz_mat_mul(AX, A, X); fmpz_mat_scalar_divexact_fmpz(AX, AX, den); if (!fmpz_mat_equal(AX, B) || !success) { flint_printf("FAIL:\n"); flint_printf("AX != B!\n"); flint_printf("A:\n"), fmpz_mat_print_pretty(A), flint_printf("\n"); flint_printf("B:\n"), fmpz_mat_print_pretty(B), flint_printf("\n"); flint_printf("X:\n"), fmpz_mat_print_pretty(X), flint_printf("\n"); flint_printf("den(X) = "), fmpz_print(den), flint_printf("\n"); flint_printf("AX:\n"), fmpz_mat_print_pretty(AX), flint_printf("\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(X); fmpz_mat_clear(AX); fmpz_clear(den); } /* Test singular systems */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { m = 1 + n_randint(state, 3); n = 1 + n_randint(state, 10); r = n_randint(state, m); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(X, m, n); fmpz_mat_init(AX, m, n); fmpz_init(den); fmpz_mat_randrank(A, state, r, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); success = fmpz_mat_solve_cramer(X, den, A, B); if (!fmpz_is_zero(den) || success) { flint_printf("FAIL:\n"); flint_printf("singular system gave nonzero determinant\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(X); fmpz_mat_clear(AX); fmpz_clear(den); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; printf("evaluate..."); fflush(stdout); flint_randinit(state); /* Check aliasing */ for (i = 0; i < 100; i++) { int ans1, ans2; mpq_t a, b; fmpz_t num, den; fmpz_poly_q_t f; mpq_init(a); mpq_init(b); fmpz_init(num); fmpz_init(den); fmpz_poly_q_init(f); fmpz_poly_q_randtest(f, state, n_randint(state, 10), 10, n_randint(state, 10), 10); fmpz_randtest(num, state, 50); fmpz_randtest_not_zero(den, state, 50); fmpz_get_mpz(mpq_numref(a), num); fmpz_get_mpz(mpq_denref(a), den); mpq_canonicalize(a); ans1 = fmpz_poly_q_evaluate(b, f, a); ans2 = fmpz_poly_q_evaluate(a, f, a); result = (ans1 == ans2) && mpq_equal(a, b); if (!result) { printf("FAIL:\n"); printf("f = "), fmpz_poly_q_print(f), printf("\n"); printf("num = "), fmpz_print(num), printf("\n"); printf("den = "), fmpz_print(den), printf("\n"); gmp_printf("a = %Qd\n", a); gmp_printf("b = %Qd\n", b); printf("ans1 = %d\n", ans1); printf("ans2 = %d\n", ans2); abort(); } mpq_clear(a); mpq_clear(b); fmpz_clear(num); fmpz_clear(den); fmpz_poly_q_clear(f); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("div_basecase...."); fflush(stdout); flint_randinit(state); /* Compare to divrem_basecase */ for (i = 0; i < 5000; i++) { fmpz_t p; fmpz_mod_poly_t a, b, q, q2, r2; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(q, p); fmpz_mod_poly_init(q2, p); fmpz_mod_poly_init(r2, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1); { fmpz_t d; fmpz *leadB = fmpz_mod_poly_lead(b); fmpz_init(d); fmpz_gcd(d, p, leadB); while (!fmpz_is_one(d)) { fmpz_divexact(leadB, leadB, d); fmpz_gcd(d, p, leadB); } fmpz_clear(d); } fmpz_mod_poly_div_basecase(q, a, b); fmpz_mod_poly_divrem_basecase(q2, r2, a, b); result = (fmpz_mod_poly_equal(q, q2)); if (!result) { printf("FAIL:\n"); printf("p = "), fmpz_print(p), printf("\n\n"); printf("a = "), fmpz_mod_poly_print(a), printf("\n\n"); printf("b = "), fmpz_mod_poly_print(b), printf("\n\n"); printf("q = "), fmpz_mod_poly_print(q), printf("\n\n"); printf("q2 = "), fmpz_mod_poly_print(q2), printf("\n\n"); printf("r2 = "), fmpz_mod_poly_print(r2), printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(q); fmpz_mod_poly_clear(q2); fmpz_mod_poly_clear(r2); fmpz_clear(p); } /* Alias a and q */ for (i = 0; i < 500; i++) { fmpz_t p; fmpz_mod_poly_t a, b, q; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(q, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1); { fmpz_t d; fmpz *leadB = fmpz_mod_poly_lead(b); fmpz_init(d); fmpz_gcd(d, p, leadB); while (!fmpz_is_one(d)) { fmpz_divexact(leadB, leadB, d); fmpz_gcd(d, p, leadB); } fmpz_clear(d); } fmpz_mod_poly_div_basecase(q, a, b); fmpz_mod_poly_div_basecase(a, a, b); result = (fmpz_mod_poly_equal(q, a)); if (!result) { printf("FAIL:\n"); printf("p = "), fmpz_print(p), printf("\n\n"); printf("a = "), fmpz_mod_poly_print(a), printf("\n\n"); printf("b = "), fmpz_mod_poly_print(b), printf("\n\n"); printf("q = "), fmpz_mod_poly_print(q), printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(q); fmpz_clear(p); } /* Alias b and q */ for (i = 0; i < 500; i++) { fmpz_t p; fmpz_mod_poly_t a, b, q; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(q, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1); { fmpz_t d; fmpz *leadB = fmpz_mod_poly_lead(b); fmpz_init(d); fmpz_gcd(d, p, leadB); while (!fmpz_is_one(d)) { fmpz_divexact(leadB, leadB, d); fmpz_gcd(d, p, leadB); } fmpz_clear(d); } fmpz_mod_poly_div_basecase(q, a, b); fmpz_mod_poly_div_basecase(b, a, b); result = (fmpz_mod_poly_equal(q, b)); if (!result) { printf("FAIL:\n"); printf("p = "), fmpz_print(p), printf("\n\n"); printf("a = "), fmpz_mod_poly_print(a), printf("\n\n"); printf("b = "), fmpz_mod_poly_print(b), printf("\n\n"); printf("q = "), fmpz_mod_poly_print(q), printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(q); fmpz_clear(p); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main() { flint_rand_t state; flint_printf("digits_round_inplace...."); fflush(stdout); flint_randinit(state); { char s[30]; slong i, j, len, n; mp_bitcnt_t shift; fmpz_t inp, out, err, t; arf_rnd_t rnd; fmpz_init(inp); fmpz_init(out); fmpz_init(err); fmpz_init(t); for (i = 0; i < 100000 * arb_test_multiplier(); i++) { len = 1 + n_randint(state, 20); n = 1 + n_randint(state, 20); s[0] = (n_randint(state, 9) + '1'); for (j = 1; j < len; j++) s[j] = (n_randint(state, 10) + '0'); s[len] = '\0'; fmpz_set_str(inp, s, 10); switch (n_randint(state, 3)) { case 0: rnd = ARF_RND_DOWN; break; case 1: rnd = ARF_RND_UP; break; default: rnd = ARF_RND_NEAR; break; } _arb_digits_round_inplace(s, &shift, err, n, rnd); fmpz_set_str(out, s, 10); fmpz_set_ui(t, 10); fmpz_pow_ui(t, t, shift); fmpz_mul(t, t, out); fmpz_add(t, t, err); if (!fmpz_equal(t, inp) || (rnd == ARF_RND_UP && fmpz_sgn(err) > 0)) { flint_printf("FAIL!\n"); flint_printf("inp = "); fmpz_print(inp); flint_printf("\n\n"); flint_printf("shift = %wd\n\n", shift); flint_printf("err = "); fmpz_print(err); flint_printf("\n\n"); flint_printf("out = "); fmpz_print(out); flint_printf("\n\n"); flint_printf(" t = "); fmpz_print(t); flint_printf("\n\n"); abort(); } } fmpz_clear(inp); fmpz_clear(out); fmpz_clear(err); fmpz_clear(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
/* todo: use log(1-z) when this is better? would also need to adjust strategy in the main function */ void acb_hypgeom_dilog_bernoulli(acb_t res, const acb_t z, slong prec) { acb_t s, w, w2; slong n, k; fmpz_t c, d; mag_t m, err; double lm; int real; acb_init(s); acb_init(w); acb_init(w2); fmpz_init(c); fmpz_init(d); mag_init(m); mag_init(err); real = 0; if (acb_is_real(z)) { arb_sub_ui(acb_realref(w), acb_realref(z), 1, 30); real = arb_is_nonpositive(acb_realref(w)); } acb_log(w, z, prec); acb_get_mag(m, w); /* for k >= 4, the terms are bounded by (|w| / (2 pi))^k */ mag_set_ui_2exp_si(err, 2670177, -24); /* upper bound for 1/(2pi) */ mag_mul(err, err, m); lm = mag_get_d_log2_approx(err); if (lm < -0.25) { n = prec / (-lm) + 1; n = FLINT_MAX(n, 4); mag_geom_series(err, err, n); BERNOULLI_ENSURE_CACHED(n) acb_mul(w2, w, w, prec); for (k = n - (n % 2 == 0); k >= 3; k -= 2) { fmpz_mul_ui(c, fmpq_denref(bernoulli_cache + k - 1), k - 1); fmpz_mul_ui(d, c, (k + 1) * (k + 2)); acb_mul(s, s, w2, prec); acb_mul_fmpz(s, s, c, prec); fmpz_mul_ui(c, fmpq_numref(bernoulli_cache + k - 1), (k + 1) * (k + 2)); acb_sub_fmpz(s, s, c, prec); acb_div_fmpz(s, s, d, prec); } acb_mul(s, s, w, prec); acb_mul_2exp_si(s, s, 1); acb_sub_ui(s, s, 3, prec); acb_mul(s, s, w2, prec); acb_mul_2exp_si(s, s, -1); acb_const_pi(w2, prec); acb_addmul(s, w2, w2, prec); acb_div_ui(s, s, 6, prec); acb_neg(w2, w); acb_log(w2, w2, prec); acb_submul(s, w2, w, prec); acb_add(res, s, w, prec); acb_add_error_mag(res, err); if (real) arb_zero(acb_imagref(res)); } else { acb_indeterminate(res); } acb_clear(s); acb_clear(w); acb_clear(w2); fmpz_clear(c); fmpz_clear(d); mag_clear(m); mag_clear(err); }
int main(void) { int i, result; flint_rand_t state; printf("derivative...."); fflush(stdout); flint_randinit(state); /* Check aliasing */ for (i = 0; i < 10000; i++) { fmpz_t p; fmpz_mod_poly_t a, b, c; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_set(b, a); fmpz_mod_poly_derivative(c, b); fmpz_mod_poly_derivative(b, b); result = (fmpz_mod_poly_equal(b, c)); if (!result) { printf("FAIL (alias):\n"); fmpz_mod_poly_print(a), printf("\n\n"); fmpz_mod_poly_print(b), printf("\n\n"); fmpz_mod_poly_print(c), printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); fmpz_clear(p); } /* Check constants have derivative zero */ for (i = 0; i < 10000; i++) { fmpz_t p; fmpz_mod_poly_t a, b; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 2)); fmpz_mod_poly_derivative(b, a); result = (b->length == 0); if (!result) { printf("FAIL (da == 0):\n"); fmpz_mod_poly_print(a), printf("\n\n"); fmpz_mod_poly_print(b), printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_clear(p); } /* Check (f g)' = f' g + f g' */ for (i = 0; i < 10000; i++) { fmpz_t p; fmpz_mod_poly_t a, b, c, d, lhs, rhs; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(c, p); fmpz_mod_poly_init(d, p); fmpz_mod_poly_init(lhs, p); fmpz_mod_poly_init(rhs, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 100)); fmpz_mod_poly_randtest(b, state, n_randint(state, 100)); fmpz_mod_poly_mul(lhs, a, b); fmpz_mod_poly_derivative(lhs, lhs); fmpz_mod_poly_derivative(c, a); fmpz_mod_poly_derivative(d, b); fmpz_mod_poly_mul(c, c, b); fmpz_mod_poly_mul(d, a, d); fmpz_mod_poly_add(rhs, c, d); result = fmpz_mod_poly_equal(lhs, rhs); if (!result) { printf("FAIL (Leibniz):\n"); printf("a = "), fmpz_mod_poly_print(a), printf("\n\n"); printf("b = "), fmpz_mod_poly_print(b), printf("\n\n"); printf("(ab)' = "), fmpz_mod_poly_print(lhs), printf("\n\n"); printf("a'b + ab' = "), fmpz_mod_poly_print(rhs), printf("\n\n"); abort(); } fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); fmpz_mod_poly_clear(d); fmpz_mod_poly_clear(lhs); fmpz_mod_poly_clear(rhs); fmpz_clear(p); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main() { long iter; flint_rand_t state; printf("set_round_ui_2exp_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { long prec, ret1, ret2; fmpz_t man, exp; fmpr_t x, y; mp_limb_t lo; fmpr_rnd_t rnd; int negative; fmpz_init(man); fmpz_init(exp); fmpr_init(x); fmpr_init(y); prec = 2 + n_randint(state, 1000); if (n_randint(state, 10) == 0) prec = FMPR_PREC_EXACT; negative = n_randint(state, 2); lo = n_randtest(state); fmpz_randtest(exp, state, 1 + n_randint(state, 100)); if (negative) fmpz_neg_ui(man, lo); else fmpz_set_ui(man, lo); switch (n_randint(state, 4)) { case 0: rnd = FMPR_RND_DOWN; break; case 1: rnd = FMPR_RND_UP; break; case 2: rnd = FMPR_RND_FLOOR; break; default: rnd = FMPR_RND_CEIL; break; } ret1 = fmpr_set_round_ui_2exp_fmpz(x, lo, exp, negative, prec, rnd); fmpr_set_fmpz_2exp(y, man, exp); ret2 = fmpr_set_round(y, y, prec, rnd); if (!fmpr_equal(x, y) || ret1 != ret2 || !fmpr_check_ulp(x, ret1, prec) || !fmpr_check_ulp(y, ret2, prec)) { printf("FAIL\n\n"); printf("prec: %ld\n", prec); printf("man = "); fmpz_print(man); printf("\n\n"); printf("exp = "); fmpz_print(exp); printf("\n\n"); printf("x = "); fmpr_print(x); printf("\n\n"); printf("y = "); fmpr_print(y); printf("\n\n"); printf("ret1 = %ld, ret2 = %ld\n\n", ret1, ret2); abort(); } fmpz_clear(man); fmpz_clear(exp); fmpr_clear(x); fmpr_clear(y); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("pow_trunc...."); fflush(stdout); /* Check aliasing */ for (i = 0; i < 10000; i++) { fmpz_mod_poly_t a, b, c; fmpz_t p; slong e, trunc; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 30)); e = n_randint(state, 20); trunc = n_randint(state, 30); fmpz_mod_poly_set(c, a); fmpz_mod_poly_pow_trunc(b, a, e, trunc); fmpz_mod_poly_pow_trunc(c, c, e, trunc); result = (fmpz_mod_poly_equal(b, c)); if (!result) { flint_printf("FAIL aliasing:\n"); flint_printf("a->length = %wd, p = %wu, exp = %wd, trunc = %wd\n", a->length, a->p, e, trunc); flint_printf("a:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n"); flint_printf("b:\n"); fmpz_mod_poly_print(b), flint_printf("\n\n"); flint_printf("c:\n"); fmpz_mod_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_clear(p); fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); } /* Check powering against naive method */ for (i = 0; i < 10000; i++) { fmpz_mod_poly_t a, b, c; fmpz_t p; slong e, trunc; fmpz_init(p); fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS); fmpz_add_ui(p, p, 2); fmpz_mod_poly_init(a, p); fmpz_mod_poly_init(b, p); fmpz_mod_poly_init(c, p); fmpz_mod_poly_randtest(a, state, n_randint(state, 30)); e = n_randint(state, 20); trunc = n_randint(state, 30); fmpz_mod_poly_pow_trunc(b, a, e, trunc); fmpz_mod_poly_pow(c, a, e); fmpz_mod_poly_truncate(c, trunc); result = (fmpz_mod_poly_equal(b, c) || (a->length == 0 && e == 0 && c->length == 1 && c->coeffs[0] == 1)); if (!result) { flint_printf("FAIL:\n"); flint_printf("a->length = %wd, p = %wu, exp = %wd, trunc = %wd\n", a->length, a->p, e, trunc); flint_printf("a:\n"); fmpz_mod_poly_print(a), flint_printf("\n\n"); flint_printf("b:\n"); fmpz_mod_poly_print(b), flint_printf("\n\n"); flint_printf("c:\n"); fmpz_mod_poly_print(c), flint_printf("\n\n"); abort(); } fmpz_clear(p); fmpz_mod_poly_clear(a); fmpz_mod_poly_clear(b); fmpz_mod_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int arf_submul(arf_ptr z, arf_srcptr x, arf_srcptr y, slong prec, arf_rnd_t rnd) { mp_size_t xn, yn, zn, tn, alloc; mp_srcptr xptr, yptr, zptr; mp_ptr tptr, tptr2; fmpz_t texp; slong shift; int tsgnbit, inexact; ARF_MUL_TMP_DECL if (arf_is_special(x) || arf_is_special(y) || arf_is_special(z)) { if (arf_is_zero(z)) { return arf_neg_mul(z, x, y, prec, rnd); } else if (arf_is_finite(x) && arf_is_finite(y)) { return arf_set_round(z, z, prec, rnd); } else { /* todo: speed up */ arf_t t; arf_init(t); arf_mul(t, x, y, ARF_PREC_EXACT, ARF_RND_DOWN); inexact = arf_sub(z, z, t, prec, rnd); arf_clear(t); return inexact; } } tsgnbit = ARF_SGNBIT(x) ^ ARF_SGNBIT(y) ^ 1; ARF_GET_MPN_READONLY(xptr, xn, x); ARF_GET_MPN_READONLY(yptr, yn, y); ARF_GET_MPN_READONLY(zptr, zn, z); fmpz_init(texp); _fmpz_add2_fast(texp, ARF_EXPREF(x), ARF_EXPREF(y), 0); shift = _fmpz_sub_small(ARF_EXPREF(z), texp); alloc = tn = xn + yn; ARF_MUL_TMP_ALLOC(tptr2, alloc) tptr = tptr2; ARF_MPN_MUL(tptr, xptr, xn, yptr, yn); tn -= (tptr[0] == 0); tptr += (tptr[0] == 0); if (shift >= 0) inexact = _arf_add_mpn(z, zptr, zn, ARF_SGNBIT(z), ARF_EXPREF(z), tptr, tn, tsgnbit, shift, prec, rnd); else inexact = _arf_add_mpn(z, tptr, tn, tsgnbit, texp, zptr, zn, ARF_SGNBIT(z), -shift, prec, rnd); ARF_MUL_TMP_FREE(tptr2, alloc) fmpz_clear(texp); return inexact; }
/** * Testing the flexibility of large index sets with a smaller kappa */ int test_jigsaw_indices(const size_t lambda, const size_t kappa, const size_t gamma, aes_randstate_t randstate) { printf("lambda: %d, kappa: %d, gamma: %d", (int) lambda, (int) kappa, (int) gamma); gghlite_sk_t self; gghlite_flag_t flags = GGHLITE_FLAGS_QUIET; gghlite_jigsaw_init_gamma(self, lambda, kappa, gamma, flags, randstate); fmpz_t p; fmpz_init(p); fmpz_poly_oz_ideal_norm(p, self->g, self->params->n, 0); /* partitioning of the universe set */ int partition[GAMMA]; for (int i = 0; i < gamma; i++) { partition[i] = rand() % kappa; } fmpz_t a[kappa]; fmpz_t acc; fmpz_init(acc); fmpz_set_ui(acc, 1); for(size_t k=0; k<kappa; k++) { fmpz_init(a[k]); fmpz_randm_aes(a[k], randstate, p); fmpz_mul(acc, acc, a[k]); fmpz_mod(acc, acc, p); } gghlite_clr_t e[kappa]; gghlite_enc_t u[kappa]; for(size_t k=0; k<kappa; k++) { gghlite_clr_init(e[k]); gghlite_enc_init(u[k], self->params); } gghlite_enc_t left; gghlite_enc_init(left, self->params); gghlite_enc_set_ui0(left, 1, self->params); for(size_t k=0; k<kappa; k++) { fmpz_poly_set_coeff_fmpz(e[k], 0, a[k]); const int i = (gghlite_sk_is_symmetric(self)) ? 0 : k; int group[GAMMA]; memset(group, 0, GAMMA * sizeof(int)); for (int j = 0; j < gamma; j++) { if (partition[j] == k) { group[j] = 1; } } gghlite_enc_set_gghlite_clr(u[k], self, e[k], 1, group, 1); gghlite_enc_mul(left, self->params, left, u[k]); } gghlite_enc_t rght; gghlite_enc_init(rght, self->params); gghlite_enc_set_ui0(rght, 1, self->params); fmpz_poly_t tmp; fmpz_poly_init(tmp); fmpz_poly_set_coeff_fmpz(tmp, 0, acc); gghlite_enc_set_gghlite_clr0(rght, self, tmp); for(size_t k=0; k<gamma; k++) { gghlite_enc_mul(rght, self->params, rght, self->z_inv[k]); } gghlite_enc_sub(rght, self->params, rght, left); int status = 1 - gghlite_enc_is_zero(self->params, rght); for(size_t i=0; i<kappa; i++) { fmpz_clear(a[i]); gghlite_clr_clear(e[i]); gghlite_enc_clear(u[i]); } gghlite_enc_clear(left); gghlite_enc_clear(rght); gghlite_clr_clear(tmp); fmpz_clear(p); gghlite_sk_clear(self, 1); if (status == 0) printf(" PASS\n"); else printf(" FAIL\n"); return status; }
void _arith_cos_minpoly(fmpz * coeffs, slong d, ulong n) { slong i, j; fmpz * alpha; fmpz_t half; mpfr_t t, u; mp_bitcnt_t prec; slong exp; if (n <= MAX_32BIT) { for (i = 0; i <= d; i++) fmpz_set_si(coeffs + i, lookup_table[n - 1][i]); return; } /* Direct formula for odd primes > 3 */ if (n_is_prime(n)) { slong s = (n - 1) / 2; switch (s % 4) { case 0: fmpz_set_si(coeffs, WORD(1)); fmpz_set_si(coeffs + 1, -s); break; case 1: fmpz_set_si(coeffs, WORD(1)); fmpz_set_si(coeffs + 1, s + 1); break; case 2: fmpz_set_si(coeffs, WORD(-1)); fmpz_set_si(coeffs + 1, s); break; case 3: fmpz_set_si(coeffs, WORD(-1)); fmpz_set_si(coeffs + 1, -s - 1); break; } for (i = 2; i <= s; i++) { slong b = (s - i) % 2; fmpz_mul2_uiui(coeffs + i, coeffs + i - 2, s+i-b, s+2-b-i); fmpz_divexact2_uiui(coeffs + i, coeffs + i, i, i-1); fmpz_neg(coeffs + i, coeffs + i); } return; } prec = magnitude_bound(d) + 5 + FLINT_BIT_COUNT(d); alpha = _fmpz_vec_init(d); fmpz_init(half); mpfr_init2(t, prec); mpfr_init2(u, prec); fmpz_one(half); fmpz_mul_2exp(half, half, prec - 1); mpfr_const_pi(t, prec); mpfr_div_ui(t, t, n, MPFR_RNDN); for (i = j = 0; j < d; i++) { if (n_gcd(n, i) == 1) { mpfr_mul_ui(u, t, 2 * i, MPFR_RNDN); mpfr_cos(u, u, MPFR_RNDN); mpfr_neg(u, u, MPFR_RNDN); exp = mpfr_get_z_2exp(_fmpz_promote(alpha + j), u); _fmpz_demote_val(alpha + j); fmpz_mul_or_div_2exp(alpha + j, alpha + j, exp + prec); j++; } } balanced_product(coeffs, alpha, d, prec); /* Scale and round */ for (i = 0; i < d + 1; i++) { slong r = d; if ((n & (n - 1)) == 0) r--; fmpz_mul_2exp(coeffs + i, coeffs + i, r); fmpz_add(coeffs + i, coeffs + i, half); fmpz_fdiv_q_2exp(coeffs + i, coeffs + i, prec); } fmpz_clear(half); mpfr_clear(t); mpfr_clear(u); _fmpz_vec_clear(alpha, d); }
int test_jigsaw(const size_t lambda, const size_t kappa, int symmetric, aes_randstate_t randstate) { printf("λ: %4zu, κ: %2zu, symmetric: %d …", lambda, kappa, symmetric); gghlite_sk_t self; gghlite_flag_t flags = GGHLITE_FLAGS_QUIET; if (symmetric) gghlite_init(self, lambda, kappa, kappa, 0x0, flags | GGHLITE_FLAGS_GOOD_G_INV, randstate); else gghlite_jigsaw_init(self, lambda, kappa, flags, randstate); fmpz_t p; fmpz_init(p); fmpz_poly_oz_ideal_norm(p, self->g, self->params->n, 0); fmpz_t a[kappa]; fmpz_t acc; fmpz_init(acc); fmpz_set_ui(acc, 1); for(size_t k=0; k<kappa; k++) { fmpz_init(a[k]); fmpz_randm_aes(a[k], randstate, p); fmpz_mul(acc, acc, a[k]); fmpz_mod(acc, acc, p); } gghlite_clr_t e[kappa]; gghlite_enc_t u[kappa]; for(size_t k=0; k<kappa; k++) { gghlite_clr_init(e[k]); gghlite_enc_init(u[k], self->params); } gghlite_enc_t left; gghlite_enc_init(left, self->params); gghlite_enc_set_ui0(left, 1, self->params); for(size_t k=0; k<kappa; k++) { fmpz_poly_set_coeff_fmpz(e[k], 0, a[k]); const int i = (gghlite_sk_is_symmetric(self)) ? 0 : k; int group[GAMMA]; memset(group, 0, GAMMA * sizeof(int)); group[i] = 1; gghlite_enc_set_gghlite_clr(u[k], self, e[k], 1, group, 1); gghlite_enc_mul(left, self->params, left, u[k]); } gghlite_enc_t rght; gghlite_enc_init(rght, self->params); gghlite_enc_set_ui0(rght, 1, self->params); fmpz_poly_t tmp; fmpz_poly_init(tmp); fmpz_poly_set_coeff_fmpz(tmp, 0, acc); gghlite_enc_set_gghlite_clr0(rght, self, tmp); for(size_t k=0; k<kappa; k++) { const int i = (gghlite_sk_is_symmetric(self)) ? 0 : k; gghlite_enc_mul(rght, self->params, rght, self->z_inv[i]); } gghlite_enc_sub(rght, self->params, rght, left); int status = 1 - gghlite_enc_is_zero(self->params, rght); for(size_t i=0; i<kappa; i++) { fmpz_clear(a[i]); gghlite_clr_clear(e[i]); gghlite_enc_clear(u[i]); } gghlite_enc_clear(left); gghlite_enc_clear(rght); gghlite_clr_clear(tmp); fmpz_clear(p); gghlite_sk_clear(self, 1); if (status == 0) printf(" PASS\n"); else printf(" FAIL\n"); return status; }
int main() { slong iter; flint_rand_t state; flint_printf("isolate_roots...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 40; iter++) { slong m, r, a, b, maxdepth, maxeval, maxfound, prec, i, j, num; arf_interval_ptr blocks; int * info; arf_interval_t interval; arb_t t; fmpz_t nn; prec = 2 + n_randint(state, 50); m = n_randint(state, 80); r = 1 + n_randint(state, 80); a = m - r; b = m + r; maxdepth = 1 + n_randint(state, 60); maxeval = 1 + n_randint(state, 5000); maxfound = 1 + n_randint(state, 100); arf_interval_init(interval); arb_init(t); fmpz_init(nn); arf_set_si(&interval->a, a); arf_set_si(&interval->b, b); num = arb_calc_isolate_roots(&blocks, &info, sin_pi2_x, NULL, interval, maxdepth, maxeval, maxfound, prec); /* check that all roots are accounted for */ for (i = a; i <= b; i++) { if (i % 2 == 0) { int found = 0; for (j = 0; j < num; j++) { arf_interval_get_arb(t, blocks + j, ARF_PREC_EXACT); if (arb_contains_si(t, i)) { found = 1; break; } } if (!found) { flint_printf("FAIL: missing root %wd\n", i); flint_printf("a = %wd, b = %wd, maxdepth = %wd, maxeval = %wd, maxfound = %wd, prec = %wd\n", a, b, maxdepth, maxeval, maxfound, prec); for (j = 0; j < num; j++) { arf_interval_printd(blocks + j, 15); flint_printf(" %d \n", info[i]); } abort(); } } } /* check that all reported single roots are good */ for (i = 0; i < num; i++) { if (info[i] == 1) { /* b contains unique 2n -> b/2 contains unique n */ arf_interval_get_arb(t, blocks + i, ARF_PREC_EXACT); arb_mul_2exp_si(t, t, -1); if (!arb_get_unique_fmpz(nn, t)) { flint_printf("FAIL: bad root %wd\n", i); flint_printf("a = %wd, b = %wd, maxdepth = %wd, maxeval = %wd, maxfound = %wd, prec = %wd\n", a, b, maxdepth, maxeval, maxfound, prec); for (j = 0; j < num; j++) { arf_interval_printd(blocks + j, 15); flint_printf(" %d \n", info[i]); } abort(); } } } _arf_interval_vec_clear(blocks, num); flint_free(info); arf_interval_clear(interval); arb_clear(t); fmpz_clear(nn); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { ulong r, s, p, prec, s_prec; ulong i, m, lambda, char1, char2; fmpz_poly_t eis, eta, eta_r; fmpz_t p1, c1, c2, ss1, ss, pp, ppl, pplc; // input r, s, and the precision desired if (argc == 4) { r = atol(argv[1]); s = atol(argv[2]); prec = atol(argv[3]); prec = n_nextprime(prec, 1) - 1; } if (argc != 4) { printf("usage: shimura_coeffs r s n\n"); return EXIT_FAILURE; } // Compute the weight of the form f_r_s lambda = r / 2 + s; //printf("%d\n", lambda); // This is the necessary precision of the input s_prec = (prec + r) * prec * r / 24; //printf("Necessary precision: %d terms\n", s_prec); // First compute eta //printf("Computing eta\n"); fmpz_poly_init(eta); eta_series(&eta, s_prec); // Next compute eta^r //printf("Computing eta^%d\n", r); fmpz_poly_init(eta_r); fmpz_poly_pow_trunc(eta_r, eta, r, s_prec); fmpz_poly_clear(eta); // Next compute E_s //printf("Computing E_%d\n", s); fmpz_poly_init(eis); if(s != 0) { eis_series(&eis, s, s_prec); } //printf("Computing coefficients\n"); // Instead of computing the product, we will compute each coefficient as // needed. This is potentially slower, but saves memory. // fmpz_init(p1); fmpz_init(c1); fmpz_init(c2); fmpz_init(ss); fmpz_init(ss1); // compute alpha(p^2*r) p = 2; m = r*p*p; while(p <= prec) { fmpz_set_ui(ss1, 0); if(s != 0) { for(i = r; i <= m; i += 24) { if((m - i) % 24 == 0) { fmpz_poly_get_coeff_fmpz(c1, eta_r, (i - r) / 24); fmpz_poly_get_coeff_fmpz(c2, eis, (m - i) / 24); fmpz_addmul(ss1, c1, c2); } } } else { if((m - r) % 24 == 0) fmpz_poly_get_coeff_fmpz(ss1, eta_r, (m - r) / 24); } /* if(p == 199) { fmpz_print(ss1); printf("\n"); } */ // compute character X12(p) char1 = n_jacobi(12, p); // compute character ((-1)^(lambda) * n | p) if(lambda % 2 == 0) { char2 = n_jacobi(r, p); } else { char2 = n_jacobi(-r, p); } // compute p^(lambda - 1) fmpz_set_ui(pp, p); fmpz_pow_ui(ppl, pp, lambda - 1); fmpz_mul_si(pplc, ppl, char1*char2); fmpz_add(ss, ss1, pplc); printf("%d:\t", p); fmpz_print(ss); printf("\n"); p = n_nextprime(p, 1); m = r*p*p; } fmpz_clear(p1); fmpz_clear(c1); fmpz_clear(c2); fmpz_clear(ss); fmpz_clear(ss1); return EXIT_SUCCESS; }
void fmpz_mod_poly_divrem_f(fmpz_t f, fmpz_mod_poly_t Q, fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B) { const slong lenA = A->length; const slong lenB = B->length; const slong lenQ = lenA - lenB + 1; fmpz *q, *r; fmpz_t invB; fmpz_init(invB); fmpz_gcdinv(f, invB, fmpz_poly_lead(B), &(B->p)); if (!fmpz_is_one(f)) { fmpz_clear(invB); return; } if (lenA < lenB) { fmpz_mod_poly_set(R, A); fmpz_mod_poly_zero(Q); fmpz_clear(invB); return; } if (Q == A || Q == B) { q = _fmpz_vec_init(lenQ); } else { fmpz_mod_poly_fit_length(Q, lenQ); q = Q->coeffs; } if (R == A || R == B) { r = _fmpz_vec_init(lenA); } else { fmpz_mod_poly_fit_length(R, lenA); r = R->coeffs; } _fmpz_mod_poly_divrem_divconquer(q, r, A->coeffs, lenA, B->coeffs, lenB, invB, &(B->p)); if (Q == A || Q == B) { _fmpz_vec_clear(Q->coeffs, Q->alloc); Q->coeffs = q; Q->alloc = lenQ; Q->length = lenQ; } else { _fmpz_mod_poly_set_length(Q, lenQ); } if (R == A || R == B) { _fmpz_vec_clear(R->coeffs, R->alloc); R->coeffs = r; R->alloc = lenA; R->length = lenA; } _fmpz_mod_poly_set_length(R, lenB - 1); _fmpz_mod_poly_normalise(R); fmpz_clear(invB); }
void eis_series(fmpz_poly_t *eis, ulong k, ulong prec) { ulong i, p, ee, p_pow, ind; fmpz_t last, last_m1, mult, fp, t_coeff, term, term_m1; long bern_fac[15] = {0, 0, 0, 0, 240, 0, -504, 0, 480, 0, -264, 0, 0, 0, -24}; // Now, we compute the eisenstein series // First, compute primes by sieving. // allocate memory for the array. /* char *primes; primes = calloc(prec + 1, sizeof(char)); for(i = 0; i <= prec; i++) { primes[i] = 1; } primes[0] = 0; primes[1] = 0; p = 2; while(p*p <= prec) { j = p*p; while(j <= prec) { primes[j] = 0; j += p; } p += 1; while(primes[p] != 1) p += 1; } */ // Now, create the eisenstein series. // We build up each coefficient using the multiplicative properties of the // divisor sum function. fmpz_poly_set_coeff_si(*eis, 0, 1); for(i = 1; i <= prec; i++) fmpz_poly_set_coeff_si(*eis, i, bern_fac[k]); fmpz_init(last); fmpz_init(last_m1); fmpz_init(mult); fmpz_init(fp); fmpz_init(t_coeff); fmpz_init(term); fmpz_init(term_m1); ee = k - 1; p = 2; while(p <= prec) { p_pow = p; fmpz_set_ui(fp, p); fmpz_pow_ui(mult, fp, ee); fmpz_pow_ui(term, mult, 2); fmpz_set(last, mult); while(p_pow <= prec) { ind = p_pow; fmpz_sub_ui(term_m1, term, 1); fmpz_sub_ui(last_m1, last, 1); while(ind <= prec) { fmpz_poly_get_coeff_fmpz(t_coeff, *eis, ind); fmpz_mul(t_coeff, t_coeff, term_m1); fmpz_divexact(t_coeff, t_coeff, last_m1); fmpz_poly_set_coeff_fmpz(*eis, ind, t_coeff); ind += p_pow; } p_pow *= p; fmpz_set(last, term); fmpz_mul(term, term, mult); } p = n_nextprime(p, 1); } fmpz_clear(last); fmpz_clear(last_m1); fmpz_clear(mult); fmpz_clear(fp); fmpz_clear(t_coeff); fmpz_clear(term); fmpz_clear(term_m1); }
void _fmpq_poly_revert_series_lagrange_fast(fmpz * Qinv, fmpz_t den, const fmpz * Q, const fmpz_t Qden, slong n) { slong i, j, k, m; fmpz *R, *Rden, *S, *T, *dens, *tmp; fmpz_t Sden, Tden, t; if (fmpz_is_one(Qden) && (n > 1) && fmpz_is_pm1(Q + 1)) { _fmpz_poly_revert_series(Qinv, Q, n); fmpz_one(den); return; } if (n <= 2) { fmpz_zero(Qinv); if (n == 2) { fmpz_set(Qinv + 1, Qden); fmpz_set(den, Q + 1); _fmpq_poly_canonicalise(Qinv, den, 2); } return; } m = n_sqrt(n); fmpz_init(t); dens = _fmpz_vec_init(n); R = _fmpz_vec_init((n - 1) * m); S = _fmpz_vec_init(n - 1); T = _fmpz_vec_init(n - 1); Rden = _fmpz_vec_init(m); fmpz_init(Sden); fmpz_init(Tden); fmpz_zero(Qinv); fmpz_one(dens); _fmpq_poly_inv_series(Ri(1), Rdeni(1), Q + 1, Qden, n - 1); _fmpq_poly_canonicalise(Ri(1), Rdeni(1), n - 1); for (i = 2; i <= m; i++) { _fmpq_poly_mullow(Ri(i), Rdeni(i), Ri(i-1), Rdeni(i-1), n - 1, Ri(1), Rdeni(1), n - 1, n - 1); _fmpq_poly_canonicalise(Ri(i), Rdeni(i), n - 1); } for (i = 1; i < m; i++) { fmpz_set(Qinv + i, Ri(i) + i - 1); fmpz_mul_ui(dens + i, Rdeni(i), i); } _fmpz_vec_set(S, Ri(m), n - 1); fmpz_set(Sden, Rdeni(m)); for (i = m; i < n; i += m) { fmpz_set(Qinv + i, S + i - 1); fmpz_mul_ui(dens + i, Sden, i); for (j = 1; j < m && i + j < n; j++) { fmpz_mul(t, S + 0, Ri(j) + i + j - 1); for (k = 1; k <= i + j - 1; k++) fmpz_addmul(t, S + k, Ri(j) + i + j - 1 - k); fmpz_set(Qinv + i + j, t); fmpz_mul(dens + i + j, Sden, Rdeni(j)); fmpz_mul_ui(dens + i + j, dens + i + j, i + j); } if (i + 1 < n) { _fmpq_poly_mullow(T, Tden, S, Sden, n - 1, Ri(m), Rdeni(m), n - 1, n - 1); _fmpq_poly_canonicalise(T, Tden, n - 1); fmpz_swap(Tden, Sden); tmp = S; S = T; T = tmp; } } _set_vec(Qinv, den, Qinv, dens, n); _fmpq_poly_canonicalise(Qinv, den, n); fmpz_clear(t); _fmpz_vec_clear(dens, n); _fmpz_vec_clear(R, (n - 1) * m); _fmpz_vec_clear(S, n - 1); _fmpz_vec_clear(T, n - 1); _fmpz_vec_clear(Rden, m); fmpz_clear(Sden); fmpz_clear(Tden); }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_nzeros_gram...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 130 + 20 * arb_test_multiplier(); iter++) { arb_t t, x; fmpz_t N, n; slong prec1, prec2; arb_init(t); arb_init(x); fmpz_init(n); fmpz_init(N); if (iter < 130) { fmpz_set_si(n, iter - 1); } else { fmpz_randtest_unsigned(n, state, 20); fmpz_add_ui(n, n, 129); } prec1 = 2 + n_randtest(state) % 100; prec2 = 2 + n_randtest(state) % 100; acb_dirichlet_zeta_nzeros_gram(N, n); acb_dirichlet_gram_point(t, n, NULL, NULL, prec1); acb_dirichlet_zeta_nzeros(x, t, prec2); if (!arb_contains_fmpz(x, N)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = "); fmpz_print(n); flint_printf(" prec1 = %wd prec2 = %wd\n\n", prec1, prec2); flint_printf("N = "); fmpz_print(N); flint_printf("\n\n"); flint_printf("t = "); arb_printn(t, 100, 0); flint_printf("\n\n"); flint_printf("x = "); arb_printn(x, 100, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(t); arb_clear(x); fmpz_clear(n); fmpz_clear(N); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(int argc, char** argv) { double s[nalgs]; int c, n, lenf, leng, len, ext, reps = 0; fmpz_t p, temp; TEMPLATE(T, poly_t) f, g, h; TEMPLATE(T, ctx_t) ctx; FLINT_TEST_INIT(state); fmpz_init(p); fmpz_set_str(p, argv[1], 10); fmpz_init(temp); fmpz_set_str(temp, argv[2], 10); ext = fmpz_get_si(temp); lenf = atol(argv[3]); leng = atol(argv[4]); len = atol(argv[5]); TEMPLATE(T, ctx_init)(ctx, p, ext, "a"); TEMPLATE(T, poly_init)(f, ctx); TEMPLATE(T, poly_init)(g, ctx); TEMPLATE(T, poly_init)(h, ctx); for (c = 0; c < nalgs; c++) { s[c] = 0.0; } for (n = 0; n < ncases; n++) { double t[nalgs]; int l, loops = 1; /* Construct random elements of fq */ { TEMPLATE(T, poly_randtest_monic)(f, state, lenf, ctx); TEMPLATE(T, poly_randtest_monic)(g, state, leng, ctx); } loop: t[0] = 0.0; init_clock(0); prof_start(); for (l = 0; l < loops; l++) { TEMPLATE(T, poly_mullow_classical)(h, f, g, len, ctx); } prof_stop(); t[0] += get_clock(0); t[1] = 0.0; init_clock(0); prof_start(); for (l = 0; l < loops; l++) { TEMPLATE(T, poly_mullow_KS)(h, f, g, len, ctx); } prof_stop(); t[1] += get_clock(0); for (c = 0; c < nalgs; c++) if (t[c] * FLINT_CLOCK_SCALE_FACTOR <= cpumin) { loops *= 10; goto loop; } for (c = 0; c < nalgs; c++) s[c] += t[c]; reps += loops; } for (c = 0; c < nalgs; c++) { flint_printf("%20f ", s[c] / (double) reps); fflush(stdout); } printf("\n"); TEMPLATE(T, poly_clear)(h, ctx); TEMPLATE(T, poly_clear)(f, ctx); TEMPLATE(T, poly_clear)(g, ctx); TEMPLATE(T, ctx_clear)(ctx); fmpz_clear(p); fmpz_clear(temp); FLINT_TEST_CLEANUP(state); return 0; }
int main(void) { fmpz_mat_t A, X, B, AX, AXm, Bm; fmpz_t mod; slong i, m, n, r; int success; FLINT_TEST_INIT(state); flint_printf("solve_dixon...."); fflush(stdout); for (i = 0; i < 100 * flint_test_multiplier(); i++) { m = n_randint(state, 20); n = n_randint(state, 20); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(Bm, m, n); fmpz_mat_init(X, m, n); fmpz_mat_init(AX, m, n); fmpz_mat_init(AXm, m, n); fmpz_init(mod); fmpz_mat_randrank(A, state, m, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); success = fmpz_mat_solve_dixon(X, mod, A, B); fmpz_mat_set(AXm, X); fmpz_mat_mul(AX, A, AXm); fmpz_mat_scalar_mod_fmpz(AXm, AX, mod); fmpz_mat_scalar_mod_fmpz(Bm, B, mod); if (!fmpz_mat_equal(AXm, Bm) || !success) { flint_printf("FAIL:\n"); flint_printf("AX != B!\n"); flint_printf("A:\n"), fmpz_mat_print_pretty(A), flint_printf("\n"); flint_printf("B:\n"), fmpz_mat_print_pretty(B), flint_printf("\n"); flint_printf("X:\n"), fmpz_mat_print_pretty(X), flint_printf("\n"); flint_printf("mod = "), fmpz_print(mod), flint_printf("\n"); flint_printf("AX:\n"), fmpz_mat_print_pretty(AX), flint_printf("\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(Bm); fmpz_mat_clear(X); fmpz_mat_clear(AX); fmpz_mat_clear(AXm); fmpz_clear(mod); } /* Test singular systems */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { m = 1 + n_randint(state, 10); n = 1 + n_randint(state, 10); r = n_randint(state, m); fmpz_mat_init(A, m, m); fmpz_mat_init(B, m, n); fmpz_mat_init(X, m, n); fmpz_init(mod); fmpz_mat_randrank(A, state, r, 1+n_randint(state, 2)*n_randint(state, 100)); fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100)); /* Dense */ if (n_randint(state, 2)) fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m)); if (fmpz_mat_solve_dixon(X, mod, A, B) != 0) { flint_printf("FAIL:\n"); flint_printf("singular system, returned nonzero\n"); abort(); } fmpz_mat_clear(A); fmpz_mat_clear(B); fmpz_mat_clear(X); fmpz_clear(mod); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }