void test_swap(char * in1, char * in2, char * out1, char * out2) { int ans; fmpz_poly_q_t op1, op2; char * res1; char * res2; fmpz_poly_q_init(op1); fmpz_poly_q_set_str(op1, in1); fmpz_poly_q_init(op2); fmpz_poly_q_set_str(op2, in2); fmpz_poly_q_swap(op1, op2); res1 = fmpz_poly_q_get_str(op1); res2 = fmpz_poly_q_get_str(op2); ans = !strcmp(out1, res1) && !strcmp(out2, res2); if (!ans) { flint_printf("test_swap: failed\n"); flint_printf(" Expected \"%s\" \"%s\", got \"%s\" \"%s\"\n", out1, out2, res1, res2); abort(); } fmpz_poly_q_clear(op1); fmpz_poly_q_clear(op2); flint_free(res1); flint_free(res2); }
static void _toposort_clear(_toposort_s *s) { flint_free(s->u); flint_free(s->v); flint_free(s->post); }
void fmpz_poly_hensel_lift_once(fmpz_poly_factor_t lifted_fac, const fmpz_poly_t f, const nmod_poly_factor_t local_fac, long N) { const long r = local_fac->num; long i; long *link; fmpz_poly_t *v, *w; link = flint_malloc((2*r - 2) * sizeof(long)); v = flint_malloc(2*(2*r - 2) * sizeof(fmpz_poly_t)); w = v + (2*r - 2); for(i = 0; i < 2*r - 2; i++) { fmpz_poly_init(v[i]); fmpz_poly_init(w[i]); } _fmpz_poly_hensel_start_lift(lifted_fac, link, v, w, f, local_fac, N); for (i = 0; i < 2*r - 2; i++) { fmpz_poly_clear(v[i]); fmpz_poly_clear(w[i]); } flint_free(link); flint_free(v); }
void spanning_tree(tree_t tree, acb_srcptr x, slong len, int type) { slong k, i, n; cdouble * w; int * t; edge_t * e; /* small approx of roots */ w = flint_malloc(len * sizeof(cdouble)); for (k = 0; k < len; k++) w[k] = acb_get_cdouble(x + k); n = (len * (len - 1)) / 2; e = flint_malloc(n * sizeof(edge_t)); if (type == INT_GC || type == INT_D2) edges_init(e, param_gc_r, w, len); else if (type == INT_DE) edges_init(e, param_de_tau, w, len); else printf("unknown type\n"), abort(); /* order edges */ qsort(e, n, sizeof(edge_t), (int(*)(const void*,const void*))edge_cmp); t = flint_malloc(len * sizeof(int)); for (k = 0; k < len; k++) t[k] = 0; for (k = 0; k < tree->n; k++) { /* start from last edge, discard if both left or taken */ /* remark: stupid to loop many times, otherwise one can * take non-connected edges but one must reorder the * edges at the end */ for (i = n - 1; k && t[e[i].a] == t[e[i].b]; i--); /* ensure a already in tree */ if (t[e[i].b]) edge_flip(e[i]); t[e[i].a] = 1; t[e[i].b] = 1; tree->e[k] = e[i]; /* save worst edge and complexity estimate */ if (!tree->r || e[i].r < tree->r) { tree->r = e[i].r; tree->min = k; } } flint_free(w); flint_free(e); flint_free(t); }
void custom_rate_mixture_clear(custom_rate_mixture_t x) { flint_free(x->rates); flint_free(x->prior); x->mode = RATE_MIXTURE_UNDEFINED; }
static void _tarjan_clear(_tarjan_t t) { flint_free(t->index); flint_free(t->lowlink); flint_free(t->onstack); _si_stack_clear(t->S); }
void acb_dirichlet_group_clear(acb_dirichlet_group_t G) { flint_free(G->primes); flint_free(G->exponents); flint_free(G->generators); flint_free(G->PHI); }
int main(void) { int i; mp_size_t j; flint_rand_t state; printf("split/combine_bits...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); for (i = 0; i < 10000; i++) { mp_size_t total_limbs = n_randint(state, 1000) + 1; mp_limb_t * in = flint_malloc(total_limbs*sizeof(mp_limb_t)); mp_limb_t * out = flint_calloc(total_limbs, sizeof(mp_limb_t)); mp_bitcnt_t bits = n_randint(state, 200) + 1; mp_size_t limbs = (2*bits - 1)/FLINT_BITS + 1; long length = (total_limbs*FLINT_BITS - 1)/bits + 1; mp_limb_t ** poly; poly = flint_malloc(length*sizeof(mp_limb_t *)); for (j = 0; j < length; j++) poly[j] = flint_malloc((limbs + 1)*sizeof(mp_limb_t)); mpn_urandomb(in, state->gmp_state, total_limbs*FLINT_BITS); fft_split_bits(poly, in, total_limbs, bits, limbs); fft_combine_bits(out, poly, length, bits, limbs, total_limbs); for (j = 0; j < total_limbs; j++) { if (in[j] != out[j]) { printf("FAIL:\n"); printf("Error in limb %ld, %lu != %lu\n", j, in[j], out[j]); abort(); } } flint_free(in); flint_free(out); for (j = 0; j < length; j++) flint_free(poly[j]); flint_free(poly); } flint_randclear(state); printf("PASS\n"); return 0; }
void tmod_mat_clear(tmod_mat_t mat) { if (mat->entries) { flint_free(mat->entries); flint_free(mat->rows); } }
void _fmpz_cleanup(void) { long i; for (i = 0; i < fmpz_num_unused; i++) mpz_clear(fmpz_arr + fmpz_unused_arr[i]); if (fmpz_num_unused) flint_free(fmpz_unused_arr); if (fmpz_allocated) flint_free(fmpz_arr); }
void fq_nmod_ctx_clear(fq_nmod_ctx_t ctx) { nmod_poly_clear(ctx->modulus); nmod_poly_clear(ctx->inv); fmpz_clear(fq_nmod_ctx_prime(ctx)); _nmod_vec_clear(ctx->a); flint_free(ctx->j); flint_free(ctx->var); }
static __inline__ void fmpz_mat_window_unsh_deep_clear( fmpz_mat_window_unsh_t W ) { slong i, siz=W->r * W->c; fmpz* e = W->rows[0]; for (i = 0; i < siz; i++, e++) fmpz_clear( e ); flint_free( W->rows[0] ); flint_free( W->rows ); }
int main(void) { int n, k, s; int * mu; printf("moebius_mu...."); fflush(stdout); check(0, n_moebius_mu(0), 0); check(1, n_moebius_mu(1), 1); for (n = 1; n < 100; n++) { mu = flint_malloc(sizeof(int) * n); n_moebius_mu_vec(mu, n); for (k = 0; k < n; k++) check(k, mu[k], n_moebius_mu(k)); flint_free(mu); } mu = flint_malloc(sizeof(int) * 10000); n_moebius_mu_vec(mu, 10000); for (k = 0; k < n; k++) check(k, mu[k], n_moebius_mu(k)); flint_free(mu); check(10000, n_moebius_mu(10000), 0); check(10001, n_moebius_mu(10001), 1); check(10002, n_moebius_mu(10002), -1); check(10003, n_moebius_mu(10003), 1); check(10004, n_moebius_mu(10004), 0); check(10005, n_moebius_mu(10005), 1); check(10006, n_moebius_mu(10006), 1); check(10007, n_moebius_mu(10007), -1); check(10008, n_moebius_mu(10008), 0); check(10009, n_moebius_mu(10009), -1); check(10010, n_moebius_mu(10010), -1); s = 0; for (k = 0; k <= 10000; k++) s += n_moebius_mu(k); if (s != -23) { printf("FAIL:\n"); printf("expected mu(k), k <= 10000 to sum to %d (got %d)\n", -23, s); abort(); } printf("PASS\n"); return 0; }
void fmpz_mod_poly_radix_clear(fmpz_mod_poly_radix_t D) { if (D->k) { const long degR = D->degR; const long k = D->k; const long lenV = degR * ((1L << k) - 1) + k; const long lenW = degR * ((1L << k) - 1); _fmpz_vec_clear(D->V, lenV + lenW); flint_free(D->Rpow); flint_free(D->Rinv); fmpz_clear(&(D->invL)); } }
void acb_dirichlet_jacobi_sum_naive(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2, slong prec) { ulong k1, k2, m1, m2, g, e, m; ulong * v1, * v2; slong *v; nmod_t expo; acb_t z; v1 = flint_malloc(G->q * sizeof(ulong)); v2 = flint_malloc(G->q * sizeof(ulong)); dirichlet_vec_set_null(v1, G, G->q); dirichlet_chi_vec_loop(v1, G, chi1, G->q); dirichlet_vec_set_null(v2, G, G->q); dirichlet_chi_vec_loop(v2, G, chi2, G->q); nmod_init(&expo, G->expo); m1 = dirichlet_order_char(G, chi1); m2 = dirichlet_order_char(G, chi2); g = m1 * m2 / n_gcd(m1, m2); m = G->expo / g; v = flint_malloc(g * sizeof(slong)); for (e = 0; e < g; e++) v[e] = 0; for (k1 = 2, k2 = G->q - 1; k2 > 1; k1++, k2--) { if (v1[k1] == DIRICHLET_CHI_NULL || v2[k2] == DIRICHLET_CHI_NULL) continue; e = nmod_add(v1[k1], v2[k2], expo) / m; v[e]++; } acb_init(z); acb_unit_root(z, g, prec); acb_dirichlet_si_poly_evaluate(res, v, g, z, prec); acb_clear(z); flint_free(v); flint_free(v2); flint_free(v1); }
void _fmpz_poly_sqrlow_KS(fmpz * res, const fmpz * poly, long len, long n) { int neg; long bits, limbs, loglen, sign = 0; mp_limb_t *arr_in, *arr_out; FMPZ_VEC_NORM(poly, len); if (len == 0) { _fmpz_vec_zero(res, n); return; } neg = (fmpz_sgn(poly + len - 1) > 0) ? 0 : -1; if (n > 2 * len - 1) { _fmpz_vec_zero(res + 2 * len - 1, n - (2 * len - 1)); n = 2 * len - 1; } bits = _fmpz_vec_max_bits(poly, len); if (bits < 0) { sign = 1; bits = - bits; } loglen = FLINT_BIT_COUNT(len); bits = 2 * bits + loglen + sign; limbs = (bits * len - 1) / FLINT_BITS + 1; arr_in = flint_calloc(limbs, sizeof(mp_limb_t)); arr_out = flint_malloc((2 * limbs) * sizeof(mp_limb_t)); _fmpz_poly_bit_pack(arr_in, poly, len, bits, neg); mpn_sqr(arr_out, arr_in, limbs); if (sign) _fmpz_poly_bit_unpack(res, n, arr_out, bits, 0); else _fmpz_poly_bit_unpack_unsigned(res, n, arr_out, bits); flint_free(arr_in); flint_free(arr_out); }
std::string renf_elem_class::to_string(int flags) const noexcept { std::string s; assert(!((flags & EANTIC_STR_D) && (flags & EANTIC_STR_ARB))); // call to renf_elem_get_str_pretty if (nf == nullptr) { if (flags & EANTIC_STR_ALG) { char * u = fmpq_get_str(nullptr, 10, b); s += u; flint_free(u); if (flags & (EANTIC_STR_D | EANTIC_STR_ARB)) s += " ~ "; } if (flags & EANTIC_STR_D) { char * u = (char *) flint_malloc(20 * sizeof(char)); sprintf(u, "%lf", fmpq_get_d(b)); s += u; flint_free(u); } if (flags & EANTIC_STR_ARB) { char * u; arb_t x; arb_init(x); arb_set_fmpq(x, b, 128); u = arb_get_str(x, 64, 0); s += u; arb_clear(x); flint_free(u); } } else { char * u = renf_elem_get_str_pretty(renf_elem_t(), parent().gen_name().c_str(), parent().renf_t(), 10, flags); s += u; flint_free(u); } if (flags != EANTIC_STR_ALG && flags != EANTIC_STR_D && flags != EANTIC_STR_ARB) return "(" + s + ")"; else return s; }
mp_limb_t _nmod_mat_det(nmod_mat_t A) { mp_limb_t det; long * P; long m = A->r; long rank; long i; P = flint_malloc(sizeof(long) * m); rank = nmod_mat_lu(P, A, 1); det = 0UL; if (rank == m) { det = 1UL; for (i = 0; i < m; i++) det = n_mulmod2_preinv(det, nmod_mat_entry(A, i, i), A->mod.n, A->mod.ninv); } if (_perm_parity(P, m) == 1) det = nmod_neg(det, A->mod); flint_free(P); return det; }
mp_limb_t tmod_mat_invert_transpose(tmod_mat_t R, const tmod_mat_t S) /* S,R square, virgin If S in inverible, R:=S inverted transposed in virgin state Return S deterimant modulo t */ { slong n=S->r; slong row_size=n*sizeof(mp_limb_t); memcpy(R->entries,S->entries,n*row_size); mp_limb_t* PR=flint_malloc(2*row_size); mp_limb_t d=0; if(tmod_mat_PLU_mod_machine_word(PR,R)) { int p_parity=count_permutation_parity(PR,n); d=tmod_mat_diag_product_ZZ_ui(R)*p_parity; tmod_mat_t K; tmod_mat_init_fast(K,n,n); _20141102_Lo(K,R,n); _20141102_Up(K,R,PR+n,n); tmod_mat_virginize(R); _20141102_unLU(R,K,n); _20141102_shift_rows(R,K,PR,n,p_parity); tmod_mat_clear(K); } flint_free(PR); return d; }
void fmpq_poly_exp_series(fmpq_poly_t res, const fmpq_poly_t poly, long n) { fmpz *copy; int alloc; if (poly->length == 0) { fmpq_poly_set_ui(res, 1UL); return; } if (!fmpz_is_zero(poly->coeffs)) { printf("Exception: fmpq_poly_exp_series: constant term != 0"); abort(); } if (n < 2) { if (n == 0) fmpq_poly_zero(res); if (n == 1) fmpq_poly_set_ui(res, 1UL); return; } if (poly->length >= n) { copy = poly->coeffs; alloc = 0; } else { long i; copy = (fmpz *) flint_malloc(n * sizeof(fmpz)); for (i = 0; i < poly->length; i++) copy[i] = poly->coeffs[i]; for ( ; i < n; i++) copy[i] = 0; alloc = 1; } if (res != poly) { fmpq_poly_fit_length(res, n); _fmpq_poly_exp_series(res->coeffs, res->den, copy, poly->den, n); } else { fmpq_poly_t t; fmpq_poly_init2(t, n); _fmpq_poly_exp_series(t->coeffs, t->den, copy, poly->den, n); fmpq_poly_swap(res, t); fmpq_poly_clear(t); } _fmpq_poly_set_length(res, n); _fmpq_poly_normalise(res); if (alloc) flint_free(copy); }
void test_submul(char * in1, char * in2, char * in3, char * out) { int ans; fmpz_poly_q_t rop, op1, op2; char * res; fmpz_poly_q_init(rop); fmpz_poly_q_set_str(rop, in1); fmpz_poly_q_init(op1); fmpz_poly_q_set_str(op1, in2); fmpz_poly_q_init(op2); fmpz_poly_q_set_str(op2, in3); fmpz_poly_q_submul(rop, op1, op2); res = fmpz_poly_q_get_str(rop); ans = !strcmp(out, res); if (!ans) { flint_printf("test_submul: failed\n"); flint_printf(" Expected \"%s\", got \"%s\"\n", out, res); abort(); } fmpz_poly_q_clear(rop); fmpz_poly_q_clear(op1); fmpz_poly_q_clear(op2); flint_free(res); }
void sample(void * arg, ulong count) { mp_limb_t n, d, r = 0; double dpre; ulong i; mp_ptr array = (mp_ptr) flint_malloc(1024*sizeof(mp_limb_t)); flint_rand_t state; flint_randinit(state); for (i = 0; i < count; i++) { int j; d = n_randtest(state); if (d == 0UL) d++; dpre = n_precompute_inverse(d); for (j = 0; j < 1024; j++) { array[j] = n_randtest(state); } prof_start(); for (j = 0; j < 10000; j++) { r += n_mod2_precomp(array[j&1023], d, dpre); } prof_stop(); } if (r == 0) abort(); flint_randclear(state); flint_free(array); }
/* in2 = in1 / in2 */ void test_div_in_place2(char * in1, char * in2, char * out) { int ans; fmpz_poly_q_t op1, op2; char * res; fmpz_poly_q_init(op1); fmpz_poly_q_set_str(op1, in1); fmpz_poly_q_init(op2); fmpz_poly_q_set_str(op2, in2); fmpz_poly_q_div(op2, op1, op2); res = fmpz_poly_q_get_str(op2); ans = !strcmp(out, res); if (!ans) { flint_printf("test_div_in_place2: failed\n"); flint_printf(" Expected \"%s\", got \"%s\"\n", out, res); abort(); } fmpz_poly_q_clear(op1); fmpz_poly_q_clear(op2); flint_free(res); }
/* Assumes poly1 and poly2 are not length 0 and len1 >= len2. */ void _fmpz_poly_mul_karatsuba(fmpz * res, const fmpz * poly1, long len1, const fmpz * poly2, long len2) { fmpz *rev1, *rev2, *out, *temp; long length, loglen = 0; if (len1 == 1) { fmpz_mul(res, poly1, poly2); return; } while ((1L << loglen) < len1) loglen++; length = (1L << loglen); rev1 = (fmpz *) flint_calloc(4 * length, sizeof(fmpz *)); rev2 = rev1 + length; out = rev1 + 2 * length; temp = _fmpz_vec_init(2 * length); revbin1(rev1, poly1, len1, loglen); revbin1(rev2, poly2, len2, loglen); _fmpz_poly_mul_kara_recursive(out, rev1, rev2, temp, loglen); _fmpz_vec_zero(res, len1 + len2 - 1); revbin2(res, out, len1 + len2 - 1, loglen + 1); _fmpz_vec_clear(temp, 2 * length); flint_free(rev1); }
void acb_dirichlet_chi_vec(acb_ptr v, const dirichlet_group_t G, const dirichlet_char_t chi, slong nv, slong prec) { slong k; ulong * a, order; acb_dirichlet_roots_t t; a = flint_malloc(nv * sizeof(ulong)); order = dirichlet_order_char(G, chi); dirichlet_chi_vec_order(a, G, chi, order, nv); acb_dirichlet_roots_init(t, order, nv, prec); acb_zero(v + 0); for (k = 0; k < nv; k++) { if (a[k] != DIRICHLET_CHI_NULL) acb_dirichlet_root(v + k, t, a[k], prec); else acb_zero(v + k); } acb_dirichlet_roots_clear(t); flint_free(a); }
void test_derivative(char * in, char * out) { int ans; fmpz_poly_q_t rop, op; char * res; fmpz_poly_q_init(op); fmpz_poly_q_set_str(op, in); fmpz_poly_q_init(rop); fmpz_poly_q_derivative(rop, op); res = fmpz_poly_q_get_str(rop); ans = !strcmp(out, res); if (!ans) { flint_printf("test_derivative: failed\n"); flint_printf(" Expected \"%s\", got \"%s\"\n", out, res); abort(); } fmpz_poly_q_clear(op); fmpz_poly_q_clear(rop); flint_free(res); }
int main(void) { double min, max; fac_one_line_t params; flint_rand_t state; int i; flint_randinit(state); params.composites = flint_malloc(1024*sizeof(ulong)); printf("factor_one_line:\n"); for (i = 4; i <= 64; i++) { fill_array(params.composites, i, state); params.bits = i; prof_repeat(&min, &max, sample, ¶ms); printf("bits = %d, time is %.3f us\n", i, max/(double)ITERS); } flint_randclear(state); flint_free(params.composites); return 0; }
renf_elem_class::renf_elem_class(const renf_class & k, const std::string & str) : renf_elem_class(k) { const char * s = str.c_str(); int err; const char * i = strchr(s, '~'); char * t; if (i != nullptr) { t = (char *) flint_malloc((i - s + 1) * sizeof(char)); strncpy(t, s, i - s); t[i - s] = '\0'; } else { t = (char *) flint_malloc((strlen(s) + 1) * sizeof(char)); strcpy(t, s); } fmpq_poly_t p; fmpq_poly_init(p); err = fmpq_poly_set_str_pretty(p, t, nf->gen_name().c_str()); if (err) { fmpq_poly_clear(p); throw std::invalid_argument("renf_elem_class fmpq_poly_set_str_pretty"); } renf_elem_set_fmpq_poly(a, p, nf->renf_t()); fmpq_poly_clear(p); flint_free(t); }
void arb_fprintn(FILE * file, const arb_t x, slong digits, ulong flags) { char * s = arb_get_str(x, digits, flags); flint_fprintf(file, "%s", s); flint_free(s); }
int main(void) { int i; flint_rand_t state; flint_randinit(state); printf("dot_ptr...."); fflush(stdout); for (i = 0; i < 10000; i++) { long len; nmod_t mod; mp_limb_t m, res, res2; mp_ptr x, y; mp_ptr * z; int limbs1; long j, offset; len = n_randint(state, 1000) + 1; m = n_randtest_not_zero(state); offset = n_randint(state, 10); nmod_init(&mod, m); x = _nmod_vec_init(len); y = _nmod_vec_init(len); z = flint_malloc(sizeof(mp_ptr) * len); _nmod_vec_randtest(x, state, len, mod); _nmod_vec_randtest(y, state, len, mod); for (j = 0; j < len; j++) z[j] = &y[j] + offset; limbs1 = _nmod_vec_dot_bound_limbs(len, mod); res = _nmod_vec_dot_ptr(x, z, -offset, len, mod, limbs1); res2 = _nmod_vec_dot(x, y, len, mod, limbs1); if (res != res2) { printf("FAIL:\n"); printf("m = %lu\n", m); printf("len = %ld\n", len); printf("limbs1 = %d\n", limbs1); abort(); } _nmod_vec_clear(x); _nmod_vec_clear(y); flint_free(z); } flint_randclear(state); printf("PASS\n"); return 0; }