int main(void) { int i, result; flint_rand_t state; printf("get_str... "); fflush(stdout); flint_randinit(state); for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t x; fmpq_t y; char *s, *t; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50) + 1; padic_ctx_init(ctx, p, N, PADIC_TERSE); padic_init(x, ctx); fmpq_init(y); padic_randtest(x, state, ctx); _padic_get_fmpq(y, x, ctx); s = _padic_get_str(NULL, x, ctx); t = fmpq_get_str(NULL, 10, y); result = strcmp(s, t) == 0; if (!result) { printf("FAIL:\n\n"); printf("x = "), _padic_print(x, ctx), printf("\n"); printf("y = "), fmpq_clear(y), printf("\n"); abort(); } free(s); free(t); _padic_clear(x); fmpq_clear(y); padic_ctx_clear(ctx); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
void fq_zech_ctx_randtest(fq_zech_ctx_t ctx, flint_rand_t state) { fmpz_t p; slong max_d, d; fq_nmod_ctx_struct * fq_nmod_ctx; fq_nmod_ctx = flint_malloc(sizeof(fq_nmod_ctx_struct)); fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 2 + n_randint(state, 4), 1)); max_d = floor(log(n_pow(2, 16)) / log(fmpz_get_ui(p))); d = n_randint(state, max_d - 1) + 2; fq_nmod_ctx_init(fq_nmod_ctx, p, d, "a"); fq_zech_ctx_init_fq_nmod_ctx(ctx, fq_nmod_ctx); fmpz_clear(p); ctx->owns_fq_nmod_ctx = 1; }
int main(void) { int i, result; flint_rand_t state; printf("exp... "); fflush(stdout); flint_randinit(state); /** p == 2 *******************************************************************/ /* Check aliasing: a = exp(a) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b; int ans1, ans2; fmpz_init(p); fmpz_set_ui(p, 2); N = n_randint(state, 50) + 1; padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_randtest(a, state, ctx); ans1 = padic_exp(b, a, ctx); ans2 = padic_exp(a, a, ctx); result = ((ans1 == ans2) && (!ans1 || padic_equal(a, b, ctx))); if (!result) { printf("FAIL (aliasing):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("ans1 = %d\n", ans1); printf("ans2 = %d\n", ans2); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Functional equation: exp(a + b) == exp(a) exp(b) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, c, d, e, f, g; int ans1, ans2, ans3; fmpz_init(p); fmpz_set_ui(p, 2); N = n_randint(state, 10) + 1; padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_init(e, ctx); padic_init(f, ctx); padic_init(g, ctx); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_add(c, a, b, ctx); ans1 = padic_exp(d, a, ctx); ans2 = padic_exp(e, b, ctx); padic_mul(f, d, e, ctx); ans3 = padic_exp(g, c, ctx); result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g, ctx))); if (!result) { printf("FAIL (functional equation):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = a + b = "), padic_print(c, ctx), printf("\n"); printf("d = exp(a) = "), padic_print(d, ctx), printf("\n"); printf("e = exp(b) = "), padic_print(e, ctx), printf("\n"); printf("f = exp(a) exp(b) = "), padic_print(f, ctx), printf("\n"); printf("g = exp(a + b) = "), padic_print(g, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); padic_clear(e, ctx); padic_clear(f, ctx); padic_clear(g, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /** p > 2 ********************************************************************/ /* Check aliasing: a = exp(a) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b; int ans1, ans2; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = n_randint(state, 50) + 1; padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_randtest(a, state, ctx); ans1 = padic_exp(b, a, ctx); ans2 = padic_exp(a, a, ctx); result = ((ans1 == ans2) && (!ans1 || padic_equal(a, b, ctx))); if (!result) { printf("FAIL (aliasing):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("ans1 = %d\n", ans1); printf("ans2 = %d\n", ans2); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Functional equation: exp(a + b) == exp(a) exp(b) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, c, d, e, f, g; int ans1, ans2, ans3; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = n_randint(state, 10) + 1; padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_init(e, ctx); padic_init(f, ctx); padic_init(g, ctx); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_add(c, a, b, ctx); ans1 = padic_exp(d, a, ctx); ans2 = padic_exp(e, b, ctx); padic_mul(f, d, e, ctx); ans3 = padic_exp(g, c, ctx); result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g, ctx))); if (!result) { printf("FAIL (functional equation):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = a + b = "), padic_print(c, ctx), printf("\n"); printf("d = exp(a) = "), padic_print(d, ctx), printf("\n"); printf("e = exp(b) = "), padic_print(e, ctx), printf("\n"); printf("f = exp(a) exp(b) = "), padic_print(f, ctx), printf("\n"); printf("g = exp(a + b) = "), padic_print(g, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); padic_clear(e, ctx); padic_clear(f, ctx); padic_clear(g, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("log_rectangular... "); fflush(stdout); flint_randinit(state); /** p == 2 *******************************************************************/ /** p > 2 ********************************************************************/ /* Check aliasing: a = log(a) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = n_randint(state, 50) + 1; padic_ctx_init(ctx, p, N, PADIC_SERIES); _padic_init(a); _padic_init(b); padic_randtest(a, state, ctx); if (!_padic_is_zero(a) && (padic_val(a) < 1 || (*p == 2L && padic_val(a) < 2))) { padic_val(a) = (*p == 2L) + 1; padic_reduce(a, ctx); } _padic_one(b); _padic_add(a, a, b, ctx); padic_log_rectangular(b, a, ctx); padic_log_rectangular(a, a, ctx); result = (padic_equal(a, b, ctx)); if (!result) { printf("FAIL (aliasing):\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("b = "), _padic_print(b, ctx), printf("\n"); abort(); } _padic_clear(a); _padic_clear(b); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check: log(a) + log(b) == log(a * b) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, c, d, e, f, g; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = n_randint(state, 50) + 1; padic_ctx_init(ctx, p, N, PADIC_SERIES); _padic_init(a); _padic_init(b); _padic_init(c); _padic_init(d); _padic_init(e); _padic_init(f); _padic_init(g); padic_randtest(a, state, ctx); if (!_padic_is_zero(a) && (padic_val(a) < 1 || (*p == 2L && padic_val(a) < 2))) { padic_val(a) = (*p == 2L) + 1; padic_reduce(a, ctx); } _padic_one(c); _padic_add(a, a, c, ctx); padic_randtest(b, state, ctx); if (!_padic_is_zero(b) && (padic_val(b) < 1 || (*p == 2L && padic_val(b) < 2))) { padic_val(b) = (*p == 2L) + 1; padic_reduce(b, ctx); } _padic_one(c); _padic_add(b, b, c, ctx); padic_mul(c, a, b, ctx); padic_log_rectangular(d, a, ctx); padic_log_rectangular(e, b, ctx); padic_add(f, d, e, ctx); padic_log_rectangular(g, c, ctx); result = (padic_equal(f, g, ctx)); if (!result) { printf("FAIL (functional equation):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = a * b = "), padic_print(c, ctx), printf("\n"); printf("d = log(a) = "), padic_print(d, ctx), printf("\n"); printf("e = log(b) = "), padic_print(e, ctx), printf("\n"); printf("f = log(a) + log(b) = "), padic_print(f, ctx), printf("\n"); printf("g = log(a * b) = "), padic_print(g, ctx), printf("\n"); abort(); } _padic_clear(a); _padic_clear(b); _padic_clear(c); _padic_clear(d); _padic_clear(e); _padic_clear(f); _padic_clear(g); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check: log(exp(x)) == x */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, c; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = n_randint(state, 50) + 1; padic_ctx_init(ctx, p, N, PADIC_SERIES); _padic_init(a); _padic_init(b); _padic_init(c); padic_randtest(a, state, ctx); if (!_padic_is_zero(a) && (padic_val(a) < 1 || (*p == 2L && padic_val(a) < 2))) { padic_val(a) = (*p == 2L) + 1; padic_reduce(a, ctx); } padic_exp(b, a, ctx); padic_log_rectangular(c, b, ctx); result = (padic_equal(a, c, ctx)); if (!result) { printf("FAIL (log(exp(x)) == x):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); abort(); } _padic_clear(a); _padic_clear(b); _padic_clear(c); fmpz_clear(p); padic_ctx_clear(ctx); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("log... "); fflush(stdout); /** p == 2 *******************************************************************/ /* Check aliasing: a = log(a) */ for (i = 0; i < 1000; i++) { fmpz_t p = {WORD(2)}; slong N; padic_ctx_t ctx; padic_t a, b; int ans1, ans2; N = __rand_prec(state, i); padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_init2(a, N); padic_init2(b, N); padic_randtest(a, state, ctx); padic_one(b); padic_add(a, a, b, ctx); ans1 = padic_log(b, a, ctx); ans2 = padic_log(a, a, ctx); result = (ans1 == ans2) && (!ans1 || padic_equal(a, b)); if (!result) { flint_printf("FAIL (aliasing):\n\n"); flint_printf("a = "), padic_print(a, ctx), flint_printf("\n"); flint_printf("b = "), padic_print(b, ctx), flint_printf("\n"); abort(); } padic_clear(a); padic_clear(b); padic_ctx_clear(ctx); } /* Check: log(a) + log(b) == log(a * b) */ for (i = 0; i < 10000; i++) { fmpz_t p = {WORD(2)}; slong N; padic_ctx_t ctx; padic_t a, b, c, d, e, f, g; int ans1, ans2, ans3; N = __rand_prec(state, i); padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_init2(a, N); padic_init2(b, N); padic_init2(c, N); padic_init2(d, N); padic_init2(e, N); padic_init2(f, N); padic_init2(g, N); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_one(c); padic_add(a, a, c, ctx); padic_add(b, b, c, ctx); padic_mul(c, a, b, ctx); ans1 = padic_log(d, a, ctx); ans2 = padic_log(e, b, ctx); padic_add(f, d, e, ctx); ans3 = padic_log(g, c, ctx); result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g))); if (!result) { flint_printf("FAIL (functional equation):\n\n"); flint_printf("a = "), padic_print(a, ctx), flint_printf("\n"); flint_printf("b = "), padic_print(b, ctx), flint_printf("\n"); flint_printf("c = a * b = "), padic_print(c, ctx), flint_printf("\n"); flint_printf("d = log(a) = "), padic_print(d, ctx), flint_printf("\n"); flint_printf("e = log(b) = "), padic_print(e, ctx), flint_printf("\n"); flint_printf("f = log(a) + log(b) = "), padic_print(f, ctx), flint_printf("\n"); flint_printf("g = log(a * b) = "), padic_print(g, ctx), flint_printf("\n"); abort(); } padic_clear(a); padic_clear(b); padic_clear(c); padic_clear(d); padic_clear(e); padic_clear(f); padic_clear(g); padic_ctx_clear(ctx); } /* Check: log(exp(x)) == x */ for (i = 0; i < 10000; i++) { fmpz_t p = {WORD(2)}; slong N; padic_ctx_t ctx; padic_t a, b, c; int ans1, ans2; N = __rand_prec(state, i); padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_init2(a, N); padic_init2(b, N); padic_init2(c, N); padic_randtest(a, state, ctx); ans1 = padic_exp(b, a, ctx); if (ans1) ans2 = padic_log(c, b, ctx); result = !ans1 || (ans1 == ans2 && padic_equal(a, c)); if (!result) { flint_printf("FAIL (log(exp(x)) == x):\n\n"); flint_printf("a = "), padic_print(a, ctx), flint_printf("\n"); flint_printf("b = "), padic_print(b, ctx), flint_printf("\n"); flint_printf("c = "), padic_print(c, ctx), flint_printf("\n"); flint_printf("ans1 = %d\n", ans1); flint_printf("ans2 = %d\n", ans2); abort(); } padic_clear(a); padic_clear(b); padic_clear(c); padic_ctx_clear(ctx); } /** p > 2 ********************************************************************/ /* Check aliasing: a = log(a) */ for (i = 0; i < 1000; i++) { fmpz_t p; slong N; padic_ctx_t ctx; padic_t a, b; int ans1, ans2; fmpz_init_set_ui(p, n_randtest_prime(state, 0)); N = __rand_prec(state, i); padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_init2(a, N); padic_init2(b, N); padic_randtest(a, state, ctx); padic_one(b); padic_add(a, a, b, ctx); ans1 = padic_log(b, a, ctx); ans2 = padic_log(a, a, ctx); result = (ans1 == ans2) && (!ans1 || padic_equal(a, b)); if (!result) { flint_printf("FAIL (aliasing):\n\n"); flint_printf("a = "), padic_print(a, ctx), flint_printf("\n"); flint_printf("b = "), padic_print(b, ctx), flint_printf("\n"); abort(); } padic_clear(a); padic_clear(b); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check: log(a) + log(b) == log(a * b) */ for (i = 0; i < 10000; i++) { fmpz_t p; slong N; padic_ctx_t ctx; padic_t a, b, c, d, e, f, g; int ans1, ans2, ans3; /* fmpz_init_set_ui(p, n_randtest_prime(state, 0)); */ fmpz_init_set_ui(p, n_randprime(state, 5, 1)); N = __rand_prec(state, i); padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_init2(a, N); padic_init2(b, N); padic_init2(c, N); padic_init2(d, N); padic_init2(e, N); padic_init2(f, N); padic_init2(g, N); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_one(c); padic_add(a, a, c, ctx); padic_one(c); padic_add(b, b, c, ctx); padic_mul(c, a, b, ctx); ans1 = padic_log(d, a, ctx); ans2 = padic_log(e, b, ctx); padic_add(f, d, e, ctx); ans3 = padic_log(g, c, ctx); result = (!ans1 || !ans2 || (ans3 && padic_equal(f, g))); if (!result) { flint_printf("FAIL (functional equation):\n\n"); flint_printf("a = "), padic_print(a, ctx), flint_printf("\n"); flint_printf("b = "), padic_print(b, ctx), flint_printf("\n"); flint_printf("c = a * b = "), padic_print(c, ctx), flint_printf("\n"); flint_printf("d = log(a) = "), padic_print(d, ctx), flint_printf("\n"); flint_printf("e = log(b) = "), padic_print(e, ctx), flint_printf("\n"); flint_printf("f = log(a) + log(b) = "), padic_print(f, ctx), flint_printf("\n"); flint_printf("g = log(a * b) = "), padic_print(g, ctx), flint_printf("\n"); flint_printf("ans1 = %d\n", ans1); flint_printf("ans2 = %d\n", ans2); flint_printf("ans3 = %d\n", ans3); abort(); } padic_clear(a); padic_clear(b); padic_clear(c); padic_clear(d); padic_clear(e); padic_clear(f); padic_clear(g); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check: log(exp(x)) == x */ for (i = 0; i < 10000; i++) { fmpz_t p; slong N; padic_ctx_t ctx; padic_t a, b, c; int ans1, ans2; fmpz_init_set_ui(p, n_randtest_prime(state, 0)); N = __rand_prec(state, i); padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_init2(a, N); padic_init2(b, N); padic_init2(c, N); padic_randtest(a, state, ctx); ans1 = padic_exp(b, a, ctx); if (ans1) ans2 = padic_log(c, b, ctx); result = !ans1 || (ans1 == ans2 && padic_equal(a, c)); if (!result) { flint_printf("FAIL (log(exp(x)) == x):\n\n"); flint_printf("a = "), padic_print(a, ctx), flint_printf("\n"); flint_printf("b = "), padic_print(b, ctx), flint_printf("\n"); flint_printf("c = "), padic_print(c, ctx), flint_printf("\n"); flint_printf("ans1 = %d\n", ans1); flint_printf("ans2 = %d\n", ans2); abort(); } padic_clear(a); padic_clear(b); padic_clear(c); fmpz_clear(p); padic_ctx_clear(ctx); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { int out = LOG; int i, ni = 8; int bits[9] = { 10, 15, 20, 25, 30, 35, 40, 45, 50 }; int j, nj = 6; ulong * v; ulong nv[6] = { 50, 200, 1000, 2000, 10000, 30000 }; int k, np = NPRIMES; nmod_t * p; ulong * a; int l, nf = 5; vec_f func[5] = { f_empty, dlog_vec_loop, dlog_vec_eratos, dlog_vec_sieve, dlog_vec }; char * n[5] = { "empty", "loop", "eratos", "sieve", "default" }; flint_rand_t state; nmod_t order; nmod_init(&order, 100); p = flint_malloc(np * sizeof(nmod_t)); a = flint_malloc(np * sizeof(ulong)); flint_randinit(state); if (argc < 2) out = LOG; else if (!strcmp(argv[1], "json")) out = JSON; else if (!strcmp(argv[1], "csv")) out = CSV; else if (!strcmp(argv[1], "log")) out = LOG; else { printf("usage: %s [log|csv|json]\n", argv[0]); abort(); } for (i = 0; i < ni; i++) { for (k = 0; k < np; k++) { nmod_init(&p[k], n_randprime(state, bits[i], 0)); a[k] = n_primitive_root_prime(p[k].n); } for (j = 0; j < nj; j++) { v = flint_malloc(nv[j] * sizeof(ulong)); if (out == LOG) { flint_printf("log(1..%wu) mod %d primes of size %d bits....\n", nv[j], np, bits[i]); fflush(stdout); } for (l = 0; l < nf; l++) { if (l == 1 && i > 2) continue; if (l == 2 && i > 5) continue; if (out == LOG) { flint_printf("%-20s... ",n[l]); fflush(stdout); } else if (out == CSV) { flint_printf("%-8s, %2d, %4d, %3d, ",n[l],bits[i],nv[j],np); } else if (out == JSON) { flint_printf("{ \"name\": \"%s\", \"bits\": %d, \"nv\": %d, \"nprimes\": %d, \"time\": ", n[l],bits[i],nv[j],np); } TIMEIT_ONCE_START for (k = 0; k < np; k++) { int kk; for (kk=0; kk < nv[j]; kk++) v[kk] = 0; (func[l])(v, nv[j], a[k], 1, p[k], p[k].n - 1, order); } TIMEIT_ONCE_STOP if (out == JSON) flint_printf("}\n"); else flint_printf("\n"); } flint_free(v); } np /= 2; } flint_free(p); flint_free(a); flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong bits, nv, iter; flint_rand_t state; int f, nf = 4; vec_f func[4] = { dlog_vec_trivial, dlog_vec_loop, dlog_vec_eratos, dlog_vec_sieve }; char * n[4] = { "trivial", "loop", "eratos", "sieve" }; flint_printf("vec...."); fflush(stdout); flint_randinit(state); for (bits = 10; bits <= FLINT_MIN(35, FLINT_BITS); bits += 5) { for (nv = 10; nv <= 10000; nv *= 10) { ulong *v, *ref; int iref; iref = (bits == 10 && nv <= 1000) ? 0 : 2; ref = flint_malloc(nv * sizeof(ulong)); v = flint_malloc(nv * sizeof(ulong)); for (iter = 0; iter < 10; iter++) { int k; ulong p, a, va, na; nmod_t mod, order; p = n_randprime(state, bits, 0); a = n_primitive_root_prime(p); nmod_init(&mod, p); va = 1; na = p - 1; nmod_init(&order, na); dlog_vec_fill(ref, nv, 0); (func[iref])(ref, nv, a, va, mod, na, order); /* compare */ for (f = iref + 1; f < nf; f++) { dlog_vec_fill(v, nv, 0); (func[f])(v, nv, a, va, mod, na, order); if ((k = dlog_vec_diff(v, ref, nv))) { flint_printf("FAIL: log(%wu,%wu) mod %wu: %s->%w != %s->%w\n", k, a, p, n[iref], ref[k], n[f], v[k]); abort(); } } } flint_free(ref); flint_free(v); } } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("sqrt... "); fflush(stdout); flint_randinit(state); /* PRIME p = 2 ***************************************************************/ /* Check aliasing: a = sqrt(a) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans1, ans2; padic_t a, d; fmpz_init(p); fmpz_set_ui(p, 2); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans1 = padic_sqrt(d, a, ctx); ans2 = padic_sqrt(a, a, ctx); result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx))); if (!result) { printf("FAIL (aliasing):\n\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random elements */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, d; fmpz_init(p); fmpz_set_ui(p, 2); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans = padic_sqrt(b, a, ctx); padic_mul(d, b, b, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (!ans || padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random squares */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, c, d; fmpz_init(p); fmpz_set_ui(p, 2); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_randtest(b, state, ctx); padic_mul(a, b, b, ctx); ans = padic_sqrt(c, a, ctx); padic_mul(d, c, c, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (ans && padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random squares):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* PRIME p > 2 ***************************************************************/ /* Check aliasing: a = sqrt(a) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans1, ans2; padic_t a, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans1 = padic_sqrt(d, a, ctx); ans2 = padic_sqrt(a, a, ctx); result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx))); if (!result) { printf("FAIL (aliasing):\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random elements */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans = padic_sqrt(b, a, ctx); padic_mul(d, b, b, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (!ans || padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random squares */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, c, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_randtest(b, state, ctx); padic_mul(a, b, b, ctx); ans = padic_sqrt(c, a, ctx); padic_mul(d, c, c, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (ans && padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random squares):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("dlog...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000; iter++) { dlog_table_t table; dlog_bsgs_t bsgs; dlog_crt_t crt; dlog_precomp_t pre1, pre100; ulong p, a, k; nmod_t modp; if (iter < 10) p = n_nth_prime(iter + 2); else p = n_randprime(state, 15, 0); nmod_init(&modp, p); a = n_primitive_root_prime(p); dlog_table_init(table, a, p); dlog_bsgs_init(bsgs, a, p, p-1, dlog_bsgs_size(p, 1)); dlog_crt_init(crt, a, p, p-1, 10); dlog_precomp_n_init(pre1, a, p, p-1, 1); dlog_precomp_n_init(pre100, a, p, p-1, 100); for (k = 1; k < 100 && k < p; k++) { ulong l0, l1, l2, l3, l4, l5; l1 = dlog_table(table, k); l2 = dlog_bsgs(bsgs, k); l3 = dlog_crt(crt, k); l4 = dlog_precomp(pre1, k); l5 = dlog_precomp(pre100, k); if (iter < 50 && k <= 7) l0 = dlog_once(k, a, modp, p-1); else l0 = l1; if (l0 != l1 || l1 != l2 || l1 != l3 || l1 != l4 || l1 != l5) { flint_printf("\n\nFAIL: log(%wu,%wu) mod %wu\n\n",k,a,p); flint_printf("once: %wu\ntable: %wu\nbsgs: %wu\ncrt: %wu\nprecomp1: %wu\nprecomp100: %wu\n\n", l0, l1, l2, l3, l4, l5); abort(); } } dlog_table_clear(table); dlog_bsgs_clear(bsgs); dlog_crt_clear(crt); dlog_precomp_clear(pre1); dlog_precomp_clear(pre100); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mul... "); fflush(stdout); /* Check aliasing: a = a * b */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c, N); qadic_randtest(a, state, ctx); qadic_randtest(b, state, ctx); qadic_mul(c, a, b, ctx); qadic_mul(a, a, b, ctx); result = (qadic_equal(a, c)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check aliasing: b = a * b */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c, N); qadic_randtest(a, state, ctx); qadic_randtest(b, state, ctx); qadic_mul(c, a, b, ctx); qadic_mul(b, a, b, ctx); result = (qadic_equal(b, c)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check aliasing: a = a + a */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, c; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(c, N); qadic_randtest(a, state, ctx); qadic_add(c, a, a, ctx); qadic_add(a, a, a, ctx); result = (qadic_equal(a, c)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(c); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check that a * b == b * a */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c1, c2; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c1, N); qadic_init2(c2, N); qadic_randtest(a, state, ctx); qadic_randtest(b, state, ctx); qadic_mul(c1, a, b, ctx); qadic_mul(c2, b, a, ctx); result = (qadic_equal(c1, c2)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c1 = "), qadic_print_pretty(c1, ctx), flint_printf("\n"); flint_printf("c2 = "), qadic_print_pretty(c2, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c1); qadic_clear(c2); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check that (a * b) * c == a * (b * c) for integral values */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c, lhs, rhs; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = n_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c, N); qadic_init2(lhs, N); qadic_init2(rhs, N); qadic_randtest_int(a, state, ctx); qadic_randtest_int(b, state, ctx); qadic_randtest_int(c, state, ctx); qadic_mul(lhs, a, b, ctx); qadic_mul(lhs, lhs, c, ctx); qadic_mul(rhs, b, c, ctx); qadic_mul(rhs, a, rhs, ctx); result = (qadic_equal(lhs, rhs)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); flint_printf("lhs = "), qadic_print_pretty(lhs, ctx), flint_printf("\n"); flint_printf("rhs = "), qadic_print_pretty(rhs, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c); qadic_clear(lhs); qadic_clear(rhs); fmpz_clear(p); qadic_ctx_clear(ctx); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int iter; FLINT_TEST_INIT(state); flint_printf("factor_squarefree...."); fflush(stdout); for (iter = 0; iter < 300; iter++) { int result = 1; fmpz_mod_poly_t pol1, poly, quot, rem; fmpz_mod_poly_factor_t res; fmpz_t modulus; slong exp[5], prod1; slong length, i, j, num; fmpz_init_set_ui(modulus, n_randtest_prime(state, 0)); fmpz_mod_poly_init(pol1, modulus); fmpz_mod_poly_init(poly, modulus); fmpz_mod_poly_init(quot, modulus); fmpz_mod_poly_init(rem, modulus); fmpz_mod_poly_zero(pol1); fmpz_mod_poly_set_coeff_ui(pol1, 0, 1); length = n_randint(state, 7) + 2; do { fmpz_mod_poly_randtest(poly, state, length); fmpz_mod_poly_make_monic(poly, poly); } while ((!fmpz_mod_poly_is_irreducible(poly)) || (poly->length < 2)); exp[0] = n_randprime(state, 5, 0); prod1 = exp[0]; for (i = 0; i < exp[0]; i++) fmpz_mod_poly_mul(pol1, pol1, poly); num = n_randint(state, 5) + 1; for (i = 1; i < num; i++) { do { length = n_randint(state, 7) + 2; fmpz_mod_poly_randtest(poly, state, length); if (poly->length) { fmpz_mod_poly_make_monic(poly, poly); fmpz_mod_poly_divrem(quot, rem, pol1, poly); } } while ((!fmpz_mod_poly_is_irreducible(poly)) || (poly->length < 2) || (rem->length == 0)); do exp[i] = n_randprime(state, 5, 0); while (prod1 % exp[i] == 0); prod1 *= exp[i]; for (j = 0; j < exp[i]; j++) fmpz_mod_poly_mul(pol1, pol1, poly); } fmpz_mod_poly_factor_init(res); fmpz_mod_poly_factor_squarefree(res, pol1); result &= (res->num == num); if (result) { ulong prod2 = 1; for (i = 0; i < num; i++) prod2 *= res->exp[i]; result &= (prod1 == prod2); } if (!result) { flint_printf("Error: exp don't match. Modulus = "); fmpz_print(modulus); flint_printf("\n"); for (i = 0; i < res->num; i++) flint_printf("%wd ", res->exp[i]); flint_printf("\n"); for (i = 0; i < num; i++) flint_printf("%wd ", exp[i]); flint_printf("\n"); abort(); } fmpz_clear(modulus); fmpz_mod_poly_clear(quot); fmpz_mod_poly_clear(rem); fmpz_mod_poly_clear(pol1); fmpz_mod_poly_clear(poly); fmpz_mod_poly_factor_clear(res); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; printf("mul... "); fflush(stdout); flint_randinit(state); /* Check aliasing: a = a * b (mod p^N) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_mul(d, a, b, ctx); padic_mul(a, a, b, ctx); result = (padic_equal(a, d, ctx)); if (!result) { printf("FAIL:\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("b = "), _padic_print(b, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check aliasing: b = a * b (mod p^N) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_mul(d, a, b, ctx); padic_mul(b, a, b, ctx); result = (padic_equal(b, d, ctx)); if (!result) { printf("FAIL:\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("b = "), _padic_print(b, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check aliasing: a = a * a (mod p^N) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); padic_mul(d, a, a, ctx); padic_mul(a, a, a, ctx); result = (padic_equal(a, d, ctx)); if (!result) { printf("FAIL:\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check that a * b == b * a (mod p^N) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, c, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_mul(c, a, b, ctx); padic_mul(d, b, a, ctx); result = (padic_equal(c, d, ctx)); if (!result) { printf("FAIL:\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("b = "), _padic_print(b, ctx), printf("\n"); printf("c = "), _padic_print(c, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check that (a * b) * c == a * (b * c), correct only mod p^{N-v} */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b, c, d, e; long v; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_init(e, ctx); padic_randtest(a, state, ctx); padic_randtest(b, state, ctx); padic_randtest(c, state, ctx); v = FLINT_MIN(padic_val(a), padic_val(b)); v = FLINT_MIN(v, padic_val(c)); v = FLINT_MIN(v, 0); if ((v >= 0) || (-v < N)) /* Otherwise, no precision left */ { padic_ctx_t ctx2; padic_ctx_init(ctx2, p, (v >= 0) ? N : N + v, PADIC_SERIES); padic_mul(d, a, b, ctx); padic_mul(d, d, c, ctx); padic_mul(e, b, c, ctx); padic_mul(e, a, e, ctx); padic_reduce(d, ctx2); padic_reduce(e, ctx2); result = (padic_equal(d, e, ctx2)); if (!result) { printf("FAIL:\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("b = "), _padic_print(b, ctx), printf("\n"); printf("c = "), _padic_print(c, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx2), printf("\n"); printf("e = "), _padic_print(e, ctx2), printf("\n"); abort(); } padic_ctx_clear(ctx2); } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); padic_clear(e, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Check that a * 1 == a */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; padic_t a, b; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 50); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_randtest(a, state, ctx); _padic_one(b); padic_mul(b, a, b, ctx); result = (padic_equal(a, b, ctx)); if (!result) { printf("FAIL:\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("b = "), _padic_print(b, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(b, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; flint_rand_t state; printf("hensel_start_continue_lift...."); fflush(stdout); flint_randinit(state); /* We check that lifting local factors of F yields factors */ for (i = 0; i < 1000; i++) { fmpz_poly_t F, G, H, R; nmod_poly_factor_t f_fac; fmpz_poly_factor_t F_fac; long bits, nbits, n, exp, j, part_exp; long r; fmpz_poly_t *v, *w; long *link; long prev_exp; bits = n_randint(state, 200) + 1; nbits = n_randint(state, FLINT_BITS - 6) + 6; fmpz_poly_init(F); fmpz_poly_init(G); fmpz_poly_init(H); fmpz_poly_init(R); nmod_poly_factor_init(f_fac); fmpz_poly_factor_init(F_fac); n = n_randprime(state, nbits, 0); exp = bits / (FLINT_BIT_COUNT(n) - 1) + 1; part_exp = n_randint(state, exp); /* Produce F as the product of random G and H */ { nmod_poly_t f; nmod_poly_init(f, n); do { do { fmpz_poly_randtest(G, state, n_randint(state, 200) + 2, bits); } while (G->length < 2); fmpz_randtest_not_zero(G->coeffs, state, bits); fmpz_one(fmpz_poly_lead(G)); do { fmpz_poly_randtest(H, state, n_randint(state, 200) + 2, bits); } while (H->length < 2); fmpz_randtest_not_zero(H->coeffs, state, bits); fmpz_one(fmpz_poly_lead(H)); fmpz_poly_mul(F, G, H); fmpz_poly_get_nmod_poly(f, F); } while (!nmod_poly_is_squarefree(f)); fmpz_poly_get_nmod_poly(f, G); nmod_poly_factor_insert(f_fac, f, 1); fmpz_poly_get_nmod_poly(f, H); nmod_poly_factor_insert(f_fac, f, 1); nmod_poly_clear(f); } r = f_fac->num; v = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t)); w = flint_malloc((2*r - 2)*sizeof(fmpz_poly_t)); link = flint_malloc((2*r - 2)*sizeof(long)); for (j = 0; j < 2*r - 2; j++) { fmpz_poly_init(v[j]); fmpz_poly_init(w[j]); } if (part_exp < 1) { _fmpz_poly_hensel_start_lift(F_fac, link, v, w, F, f_fac, exp); } else { fmpz_t nn; fmpz_init_set_ui(nn, n); prev_exp = _fmpz_poly_hensel_start_lift(F_fac, link, v, w, F, f_fac, part_exp); _fmpz_poly_hensel_continue_lift(F_fac, link, v, w, F, prev_exp, part_exp, exp, nn); fmpz_clear(nn); } result = 1; for (j = 0; j < F_fac->num; j++) { fmpz_poly_rem(R, F, F_fac->p + j); result &= (R->length == 0); } for (j = 0; j < 2*r - 2; j++) { fmpz_poly_clear(v[j]); fmpz_poly_clear(w[j]); } flint_free(link); flint_free(v); flint_free(w); if (!result) { printf("FAIL:\n"); printf("bits = %ld, n = %ld, exp = %ld\n", bits, n, exp); fmpz_poly_print(F); printf("\n\n"); fmpz_poly_print(G); printf("\n\n"); fmpz_poly_print(H); printf("\n\n"); fmpz_poly_factor_print(F_fac); printf("\n\n"); abort(); } nmod_poly_factor_clear(f_fac); fmpz_poly_factor_clear(F_fac); fmpz_poly_clear(F); fmpz_poly_clear(H); fmpz_poly_clear(G); fmpz_poly_clear(R); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; flint_randinit(state); printf("rem...."); fflush(stdout); /* Check result of rem */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, q, r, prod; mp_limb_t n; do n = n_randtest_not_zero(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(q, n); nmod_poly_init(r, n); nmod_poly_init(prod, n); nmod_poly_randtest(a, state, n_randint(state, 2000)); do nmod_poly_randtest(b, state, n_randint(state, 2000)); while (b->length == 0); nmod_poly_div(q, a, b); nmod_poly_rem(r, a, b); nmod_poly_mul(prod, q, b); nmod_poly_add(prod, prod, r); result = (nmod_poly_equal(a, prod)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(prod), printf("\n\n"); nmod_poly_print(q), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(q); nmod_poly_clear(r); nmod_poly_clear(prod); } /* Check aliasing of a and r */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, r; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(r, n); nmod_poly_randtest(a, state, n_randint(state, 2000)); do nmod_poly_randtest(b, state, n_randint(state, 2000)); while (b->length == 0); nmod_poly_rem(r, a, b); nmod_poly_rem(a, a, b); result = (nmod_poly_equal(a, r)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(r); } /* Check aliasing of b and r */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, r; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(r, n); nmod_poly_randtest(a, state, n_randint(state, 2000)); do nmod_poly_randtest(b, state, n_randint(state, 2000)); while (b->length == 0); nmod_poly_rem(r, a, b); nmod_poly_rem(b, a, b); result = (nmod_poly_equal(b, r)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(r); } /* Check result of rem_q1 */ for (i = 0; i < 5000; i++) { nmod_poly_t a, b, q0, r0, r; mp_limb_t n = n_randprime(state, n_randint(state,FLINT_BITS-1)+2, 0); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(q0, n); nmod_poly_init(r0, n); nmod_poly_init(r, n); do nmod_poly_randtest(a, state, n_randint(state, 1000)); while (a->length < 2); nmod_poly_fit_length(b, a->length - 1); mpn_zero(b->coeffs, a->length - 1); nmod_poly_randtest_not_zero(b, state, n_randint(state, 1000) + 1); do b->coeffs[a->length - 2] = n_randint(state, n); while (b->coeffs[a->length - 2] == 0); b->length = a->length - 1; nmod_poly_divrem(q0, r0, a, b); nmod_poly_rem(r, a, b); result = (nmod_poly_equal(r0, r)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(q0), printf("\n\n"); nmod_poly_print(r0), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(q0); nmod_poly_clear(r0); nmod_poly_clear(r); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("norm... "); fflush(stdout); /* Compare with product of Galois conjugates */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c; padic_t x, y; slong j; int ans; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c, N); padic_init2(x, N); padic_init2(y, N); qadic_randtest_val(a, state, 0, ctx); qadic_reduce(a, ctx); qadic_norm(x, a, ctx); qadic_one(b); for (j = 0; j < d; j++) { qadic_frobenius(c, a, j, ctx); qadic_mul(b, b, c, ctx); } ans = qadic_get_padic(y, b, ctx); result = (ans && padic_equal(x, y)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("x = "), padic_print(x, &ctx->pctx), flint_printf("\n"); flint_printf("y = "), padic_print(y, &ctx->pctx), flint_printf("\n"); for (j = 0; j < d; j++) { qadic_frobenius(c, a, j, ctx); flint_printf("sigma^%wd = ", j), qadic_print_pretty(c, ctx), flint_printf("\n"); } flint_printf("ans = %d\n", ans); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c); padic_clear(x); padic_clear(y); fmpz_clear(p); qadic_ctx_clear(ctx); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }