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