int main(int argc, char *args[]) /*setup.txt:lev,d, {q, n, bign} */
{
FILE *fp;
if((fp = fopen(args[1], "r")) == NULL)
{
printf("file read error\n");
exit(0);
}
char str[100];
fmpz_t tmp;
fmpz_init(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
long lev, d, i, j, row;
lev = fmpz_get_si(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
d = fmpz_get_si(tmp);
FILE *skf;
char name[]="sk1.txt";
for( i = lev ; i >= 0; i-- ) {
param_node_t *h;
fmpz_mat_t sk;
h = param_node_init(h);
fgets(str, 100, fp);
fmpz_set_str(h->q, str, 10);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
h->n = fmpz_get_si(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
h->bign = fmpz_get_si(tmp);
row = 1 + h->n;
fmpz_mat_init(sk, row, 1);
e_skeygen(sk, h);
name[2] = '0' + i;
if((skf = fopen(name, "w")) == NULL)
{
printf("file open error\n");
exit(0);
}
int flag = fmpz_mat_fprint(skf, sk);
if(flag < 0) {
printf("file write error\n");
exit(0);
}
fclose(skf);
fmpz_mat_clear(sk);
}
fclose(fp);
fmpz_clear(tmp);
return 0;
}
int fq2bn(bn_t out, fq_t in, fq_ctx_t ctx)
{
fmpz_t temp;
fmpz_init(temp);
fmpz_set_str(temp, fq_get_str_pretty(in, ctx), 10);
fmpz2bn(out, temp);
fmpz_clear(temp);
return 0;
}
int main()
{
long iter;
flint_rand_t state;
printf("const_glaisher....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 250; iter++)
{
arb_t r, s, t;
fmpz_t v;
long accuracy, prec;
prec = 2 + n_randint(state, 2000);
arb_init(r);
arb_init(s);
arb_init(t);
fmpz_init(v);
arb_const_glaisher(r, prec);
arb_const_glaisher(s, prec + 100);
if (!arb_overlaps(r, s))
{
printf("FAIL: containment\n\n");
printf("prec = %ld\n", prec);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 4)
{
printf("FAIL: poor accuracy\n\n");
printf("prec = %ld\n", prec);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
abort();
}
if (n_randint(state, 30) == 0)
{
flint_cleanup();
}
fmpz_set_str(v, "128242712910062263687534256886979172776768892732500", 10);
arb_set_fmpz(t, v);
mag_one(arb_radref(t));
fmpz_ui_pow_ui(v, 10, 50);
arb_div_fmpz(t, t, v, 170);
if (!arb_overlaps(r, t))
{
printf("FAIL: reference value\n\n");
printf("prec = %ld\n", prec);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
abort();
}
arb_clear(r);
arb_clear(s);
arb_clear(t);
fmpz_clear(v);
}
flint_randclear(state);
flint_cleanup();
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;
}
void test_field2(flint_rand_t state)
{
/* test in QQ[3^(1/4)] */
renf_t nf;
renf_elem_t a;
fmpq_t d, k;
fmpq_poly_t p;
fmpq_init(d);
fmpq_poly_init(p);
fmpq_set_si(d, 3, 1);
renf_init_nth_root_fmpq(nf, d, 4, 10 + n_randint(state, 10));
fmpq_clear(d);
fmpq_init(k);
renf_elem_init(a, nf);
/* test rationals */
/* --> 3^(1/4) */
fmpq_poly_set_coeff_si(p, 1, 1);
renf_elem_set_fmpq_poly(a, p, nf);
check_ceil(a, nf, 2, "3^(1/4)");
/* --> 3^(1/4) - p_34 / q_34 */
/* ceil = 1 */
fmpz_set_str(fmpq_numref(k), "3871793620206447926", 10);
fmpz_set_str(fmpq_denref(k), "2941926960111028069", 10);
fmpq_neg(k, k);
fmpq_poly_set_coeff_fmpq(p, 0, k);
renf_elem_set_fmpq_poly(a, p, nf);
check_ceil(a, nf, 1, "3^(1/4)");
/* --> 3^(1/4) - p_35 / q_35 */
/* ceil = 0 */
fmpz_set_str(fmpq_numref(k), "4393442218385055959", 10);
fmpz_set_str(fmpq_denref(k), "3338294180377262795", 10);
fmpq_neg(k, k);
fmpq_poly_set_coeff_fmpq(p, 0, k);
renf_elem_set_fmpq_poly(a, p, nf);
check_ceil(a, nf, 0, "3^(1/4)");
/* --> 3^(1/4) - p_200 / q_200 */
fmpz_set_str(fmpq_numref(k), "51566086581654990699052199424489069476470199719930170996263916596162993841059250500042162091", 10);
fmpz_set_str(fmpq_denref(k), "39181752754141206003124111890355840072199542360218864430892618765033598468868752146602163065", 10);
fmpq_neg(k, k);
fmpq_poly_set_coeff_fmpq(p, 0, k);
renf_elem_set_fmpq_poly(a, p, nf);
check_ceil(a, nf, 1, "3^(1/4)");
/* --> 3^(1/4) - p_201 / q_201 */
fmpz_set_str(fmpq_numref(k), "80796322887694335717970676356641716096406222234122724217891106756946083353628876437327250032", 10);
fmpz_set_str(fmpq_denref(k), "61391929399498685496270115285641595325756438975454257165479021482386018841773493669624721869", 10);
fmpq_neg(k, k);
fmpq_poly_set_coeff_fmpq(p, 0, k);
renf_elem_set_fmpq_poly(a, p, nf);
check_ceil(a, nf, 0, "3^(1/4)");
/* */
fmpz_set_str(fmpq_numref(k), "13231942875843754343234", 10);
fmpz_set_str(fmpq_denref(k), "14321431341231112121", 10);
fmpq_poly_set_coeff_fmpq(p, 3, k);
fmpz_set_str(fmpq_numref(k), "148589873455543948591", 10);
fmpz_set_str(fmpq_denref(k), "12332111221111", 10);
fmpq_neg(k, k);
fmpq_poly_set_coeff_fmpq(p, 2, k);
fmpz_set_str(fmpq_numref(k), "1233321469998711012392391", 10);
fmpz_set_str(fmpq_denref(k), "11814121556810191", 10);
fmpq_poly_set_coeff_fmpq(p, 1, k);
fmpz_set_str(fmpq_numref(k), "1249152314425433983202991363672458443993964487436329478959287771807457205881969983777233465754608376177969464841", 10);
fmpz_set_str(fmpq_denref(k), "10720278662399817731713810382544982753044312944075797382817281426908463944866446042500978893159281330135", 10);
fmpq_neg(k, k);
fmpq_poly_set_coeff_fmpq(p, 0, k);
renf_elem_set_fmpq_poly(a, p, nf);
check_ceil(a, nf, 231, "3^(1/4)");
renf_elem_clear(a, nf);
renf_clear(nf);
fmpq_clear(k);
fmpq_poly_clear(p);
}
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;
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("sqrtmod....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++) /* Test random integers */
{
int ans;
fmpz_t a, b, c, p;
mp_limb_t prime;
prime = n_randint(state, UWORD(1) << (FLINT_BITS - 1));
prime = n_nextprime(prime, 1);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(p);
fmpz_set_ui(p, prime);
fmpz_randm(a, state, p);
ans = fmpz_sqrtmod(b, a, p);
fmpz_mul(c, b, b);
fmpz_mod(c, c, p);
result = (ans == 0 || fmpz_equal(a, c));
if (!result)
{
flint_printf("FAIL (random):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n");
flint_printf("b = "), fmpz_print(b), flint_printf("\n");
flint_printf("c = "), fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(p);
}
for (i = 0; i < 100 * flint_test_multiplier(); i++) /* Test random squares */
{
int ans;
fmpz_t a, b, c, d, p;
mp_limb_t prime;
prime = n_randint(state, UWORD(1) << (FLINT_BITS - 1));
prime = n_nextprime(prime, 1);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(d);
fmpz_init(p);
fmpz_set_ui(p, prime);
do
fmpz_randm(b, state, p);
while (fmpz_is_zero(b));
fmpz_mul(a, b, b);
fmpz_mod(a, a, p);
/* check a special case */
if (i == 0)
{
fmpz_set_str(p, "15951355998396157", 10);
fmpz_set_str(a, "7009303413761286", 10);
}
ans = fmpz_sqrtmod(c, a, p);
fmpz_mul(d, c, c);
fmpz_mod(d, d, p);
result = (ans && fmpz_equal(a, d));
if (!result)
{
flint_printf("FAIL (squares):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n");
flint_printf("a (= b^2) = "), fmpz_print(a), flint_printf("\n");
flint_printf("b = "), fmpz_print(b), flint_printf("\n");
flint_printf("c (= sqrt(a) = "), fmpz_print(c), flint_printf("\n");
flint_printf("d (= c^2) = "), fmpz_print(d), flint_printf("\n");
flint_printf("ans = %d\n", ans);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(d);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
static int
arb_set_float_str(arb_t res, const char * inp, slong prec)
{
char * emarker;
char * buf;
int error;
slong i;
fmpz_t exp;
fmpz_t man;
slong num_int, num_frac;
int after_radix;
if (inp[0] == '+')
{
return arb_set_float_str(res, inp + 1, prec);
}
if (inp[0] == '-')
{
error = arb_set_float_str(res, inp + 1, prec);
arb_neg(res, res);
return error;
}
if (strcmp(inp, "inf") == 0)
{
arb_pos_inf(res);
return 0;
}
if (strcmp(inp, "nan") == 0)
{
arb_indeterminate(res);
return 0;
}
error = 0;
fmpz_init(exp);
fmpz_init(man);
buf = flint_malloc(strlen(inp) + 1);
emarker = strchr(inp, 'e');
/* parse exponent (0 by default) */
if (emarker != NULL)
{
/* allow e+42 as well as e42 */
if (emarker[1] == '+')
{
if (!(emarker[2] >= '0' && emarker[2] <= '9'))
error = 1;
else
error = fmpz_set_str(exp, emarker + 2, 10);
}
else
error = fmpz_set_str(exp, emarker + 1, 10);
if (error)
goto cleanup;
}
/* parse floating-point part */
{
num_int = 0;
num_frac = 0;
after_radix = 0;
for (i = 0; inp + i != emarker && inp[i] != '\0'; i++)
{
if (inp[i] == '.' && !after_radix)
{
after_radix = 1;
}
else if (inp[i] >= '0' && inp[i] <= '9')
{
buf[num_int + num_frac] = inp[i];
num_frac += after_radix;
num_int += !after_radix;
}
else
{
error = 1;
goto cleanup;
}
}
buf[num_int + num_frac] = '\0';
/* put trailing zeros into the exponent */
while (num_int + num_frac > 1 && buf[num_int + num_frac - 1] == '0')
{
buf[num_int + num_frac - 1] = '\0';
num_frac--;
}
fmpz_sub_si(exp, exp, num_frac);
error = fmpz_set_str(man, buf, 10);
if (error)
goto cleanup;
}
if (fmpz_is_zero(man))
{
arb_zero(res);
}
else if (fmpz_is_zero(exp))
{
arb_set_round_fmpz(res, man, prec);
}
else
{
arb_t t;
arb_init(t);
arb_set_ui(t, 10);
arb_set_fmpz(res, man);
if (fmpz_sgn(exp) > 0)
{
arb_pow_fmpz_binexp(t, t, exp, prec + 4);
arb_mul(res, res, t, prec);
}
else
{
fmpz_neg(exp, exp);
arb_pow_fmpz_binexp(t, t, exp, prec + 4);
arb_div(res, res, t, prec);
}
arb_clear(t);
}
cleanup:
fmpz_clear(exp);
fmpz_clear(man);
flint_free(buf);
if (error)
arb_indeterminate(res);
return error;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("resultant_modular_div....");
fflush(stdout);
/* Just one specific test */
{
fmpz_poly_t f, g;
fmpz_t a, b, div;
slong nbits;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_init(a);
fmpz_init(b);
fmpz_init(div);
fmpz_poly_set_str(f, "11 -15 -2 -2 17 0 0 6 0 -5 1 -1");
fmpz_poly_set_str(g, "9 2 1 1 1 1 1 0 -1 -2");
fmpz_set_str(div, "11", 10);
nbits = 42;
fmpz_poly_resultant_modular_div(a, f, g, div, nbits);
/* The result is -44081924855067 = -4007447714097 * 11
* We supply 11 and the missing divisor is less then 2^35 */
fmpz_set_str(b, "-4007447714097", 10);
result = (fmpz_equal(a, b));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("f(x) = "), fmpz_poly_print_pretty(f, "x"), flint_printf("\n\n");
flint_printf("g(x) = "), fmpz_poly_print_pretty(g, "x"), flint_printf("\n\n");
flint_printf("res(f, h)/div = "), fmpz_print(b), flint_printf("\n\n");
flint_printf("res_mod_div(f, h) = "), fmpz_print(a), flint_printf("\n\n");
flint_printf("divr = "), fmpz_print(div), flint_printf("\n\n");
flint_printf("bitsbound = %wd", nbits), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(div);
}
/* Check that R(fg, h) = R(f, h) R(g, h) */
for (i = 0; i < 100; i++)
{
fmpz_t a, b, c, d;
fmpz_poly_t f, g, h, p;
slong nbits;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(d);
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_init(p);
fmpz_poly_randtest(f, state, n_randint(state, 50), 100);
fmpz_poly_randtest(g, state, n_randint(state, 50), 100);
fmpz_poly_randtest(h, state, n_randint(state, 50), 100);
fmpz_poly_resultant_modular(a, f, h);
fmpz_poly_resultant_modular(b, g, h);
if (fmpz_is_zero(b) || fmpz_is_zero(a))
{
fmpz_clear(b);
fmpz_clear(a);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
continue;
}
fmpz_mul(c, a, b);
fmpz_poly_mul(p, f, g);
nbits = (slong)fmpz_bits(a) + 1; /* for sign */
fmpz_poly_resultant_modular_div(d, p, h, b, nbits);
result = (fmpz_equal(a, d));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("p(x) = "), fmpz_poly_print_pretty(p, "x"), flint_printf("\n\n");
flint_printf("h(x) = "), fmpz_poly_print_pretty(h, "x"), flint_printf("\n\n");
flint_printf("res(p, h) = "), fmpz_print(c), flint_printf("\n\n");
flint_printf("res(p, h) = "), fmpz_print(a), flint_printf(" * "), fmpz_print(b), flint_printf("\n\n");
flint_printf("supplied divisor = "), fmpz_print(b), flint_printf("\n\n");
flint_printf("result should be = "), fmpz_print(a), flint_printf("\n\n");
flint_printf("res(p, h)/div = "), fmpz_print(d), flint_printf("\n\n");
flint_printf("bitsbound for result = %wd", nbits), flint_printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(d);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
fmpz_poly_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(int argc, char *argv[])
{
fmpz_poly_t f, g;
fmpz_poly_factor_t fac;
fmpz_t t;
slong compd, printd, i, j;
if (argc < 2)
{
flint_printf("poly_roots [-refine d] [-print d] <poly>\n\n");
flint_printf("Isolates all the complex roots of a polynomial with integer coefficients.\n\n");
flint_printf("If -refine d is passed, the roots are refined to an absolute tolerance\n");
flint_printf("better than 10^(-d). By default, the roots are only computed to sufficient\n");
flint_printf("accuracy to isolate them. The refinement is not currently done efficiently.\n\n");
flint_printf("If -print d is passed, the computed roots are printed to d decimals.\n");
flint_printf("By default, the roots are not printed.\n\n");
flint_printf("The polynomial can be specified by passing the following as <poly>:\n\n");
flint_printf("a <n> Easy polynomial 1 + 2x + ... + (n+1)x^n\n");
flint_printf("t <n> Chebyshev polynomial T_n\n");
flint_printf("u <n> Chebyshev polynomial U_n\n");
flint_printf("p <n> Legendre polynomial P_n\n");
flint_printf("c <n> Cyclotomic polynomial Phi_n\n");
flint_printf("s <n> Swinnerton-Dyer polynomial S_n\n");
flint_printf("b <n> Bernoulli polynomial B_n\n");
flint_printf("w <n> Wilkinson polynomial W_n\n");
flint_printf("e <n> Taylor series of exp(x) truncated to degree n\n");
flint_printf("m <n> <m> The Mignotte-like polynomial x^n + (100x+1)^m, n > m\n");
flint_printf("coeffs <c0 c1 ... cn> c0 + c1 x + ... + cn x^n\n\n");
flint_printf("Concatenate to multiply polynomials, e.g.: p 5 t 6 coeffs 1 2 3\n");
flint_printf("for P_5(x)*T_6(x)*(1+2x+3x^2)\n\n");
return 1;
}
compd = 0;
printd = 0;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_init(t);
fmpz_poly_one(f);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-refine"))
{
compd = atol(argv[i+1]);
i++;
}
else if (!strcmp(argv[i], "-print"))
{
printd = atol(argv[i+1]);
i++;
}
else if (!strcmp(argv[i], "a"))
{
slong n = atol(argv[i+1]);
fmpz_poly_zero(g);
for (j = 0; j <= n; j++)
fmpz_poly_set_coeff_ui(g, j, j+1);
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "t"))
{
arith_chebyshev_t_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "u"))
{
arith_chebyshev_u_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "p"))
{
fmpq_poly_t h;
fmpq_poly_init(h);
arith_legendre_polynomial(h, atol(argv[i+1]));
fmpq_poly_get_numerator(g, h);
fmpz_poly_mul(f, f, g);
fmpq_poly_clear(h);
i++;
}
else if (!strcmp(argv[i], "c"))
{
arith_cyclotomic_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "s"))
{
arith_swinnerton_dyer_polynomial(g, atol(argv[i+1]));
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "b"))
{
fmpq_poly_t h;
fmpq_poly_init(h);
arith_bernoulli_polynomial(h, atol(argv[i+1]));
fmpq_poly_get_numerator(g, h);
fmpz_poly_mul(f, f, g);
fmpq_poly_clear(h);
i++;
}
else if (!strcmp(argv[i], "w"))
{
slong n = atol(argv[i+1]);
fmpz_poly_zero(g);
fmpz_poly_fit_length(g, n+2);
arith_stirling_number_1_vec(g->coeffs, n+1, n+2);
_fmpz_poly_set_length(g, n+2);
fmpz_poly_shift_right(g, g, 1);
fmpz_poly_mul(f, f, g);
i++;
}
else if (!strcmp(argv[i], "e"))
{
fmpq_poly_t h;
fmpq_poly_init(h);
fmpq_poly_set_coeff_si(h, 0, 0);
fmpq_poly_set_coeff_si(h, 1, 1);
fmpq_poly_exp_series(h, h, atol(argv[i+1]) + 1);
fmpq_poly_get_numerator(g, h);
fmpz_poly_mul(f, f, g);
fmpq_poly_clear(h);
i++;
}
else if (!strcmp(argv[i], "m"))
{
fmpz_poly_zero(g);
fmpz_poly_set_coeff_ui(g, 0, 1);
fmpz_poly_set_coeff_ui(g, 1, 100);
fmpz_poly_pow(g, g, atol(argv[i+2]));
fmpz_poly_set_coeff_ui(g, atol(argv[i+1]), 1);
fmpz_poly_mul(f, f, g);
i += 2;
}
else if (!strcmp(argv[i], "coeffs"))
{
fmpz_poly_zero(g);
i++;
j = 0;
while (i < argc)
{
if (fmpz_set_str(t, argv[i], 10) != 0)
{
i--;
break;
}
fmpz_poly_set_coeff_fmpz(g, j, t);
i++;
j++;
}
fmpz_poly_mul(f, f, g);
}
}
fmpz_poly_factor_init(fac);
flint_printf("computing squarefree factorization...\n");
TIMEIT_ONCE_START
fmpz_poly_factor_squarefree(fac, f);
TIMEIT_ONCE_STOP
TIMEIT_ONCE_START
for (i = 0; i < fac->num; i++)
{
flint_printf("roots with multiplicity %wd\n", fac->exp[i]);
fmpz_poly_complex_roots_squarefree(fac->p + i,
32, compd * 3.32193 + 2, printd);
}
TIMEIT_ONCE_STOP
fmpz_poly_factor_clear(fac);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_clear(t);
flint_cleanup();
return EXIT_SUCCESS;
}
int main(int argc, char *args[])/* setup.txt, ct.txt{ct->lev, ct->row, ct->col, ct}, sk.txt{row, col, poly}*/
{
FILE *fp;
if((fp = fopen(args[1], "r")) == NULL)
{
printf("file read error\n");
exit(0);
}
fmpz_t tmp;
fmpz_init(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
long lev, d, i, j;
lev = fmpz_get_si(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
d = fmpz_get_si(tmp);
fmpz_poly_t fx;
fmpz_poly_init(fx);
fmpz_poly_set_coeff_si(fx, 0, 1);
fmpz_poly_set_coeff_si(fx, d, 1);
param_node_t *ph, *pr, *ps, *param;
ph = param_node_init(ph);
ps = ph;
for( i = 0 ; i <= lev; i++ ) {
pr = param_node_init(pr);
fgets(str, 100, fp);
fmpz_set_str(pr->q, str, 10);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
pr->n = fmpz_get_si(tmp);
fgets(str, 100, fp);
fmpz_set_str(tmp, str, 10);
pr->bign = fmpz_get_si(tmp);
ps->next = pr;
ps = pr;
}
ps->next = NULL;
fclose(fp);
param = ph->next;
long row, col, ctlev;
if((fp = fopen(args[2], "r")) == NULL)
{
printf("file read error\n");
exit(0);
}
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
ctlev = fmpz_get_si(tmp);
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
row = fmpz_get_si(tmp);
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
col = fmpz_get_si(tmp);
fmpz_poly_mat_t ct;
fmpz_poly_mat_init(ct, row, col);
for( i = 0 ; i < row ; i++) {
for(j = 0; j < col ; j++) {
fgets(str, 100000, fp);
fmpz_poly_set_str(fmpz_poly_mat_entry(ct, i, j), str);
}
}
fclose(fp);
if((fp = fopen(args[3], "r")) == NULL)
{
printf("file read error\n");
exit(0);
}
long l;
sk_node_t *sh, *ss, *sr;
sh = (sk_node_t *)malloc(sizeof(sk_node_t));
ss = sh;
for(l = 0; l <= lev ; l++){
sr = (sk_node_t *)malloc(sizeof(sk_node_t));
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
row = fmpz_get_si(tmp);
fgets(str, 30, fp);
fmpz_set_str(tmp, str,10);
col = fmpz_get_si(tmp);
fmpz_poly_mat_init(sr->sk, row, col);
for( i = 0 ; i < row ; i++) {
for(j = 0; j < col ; j++) {
fgets(str, 100000, fp);
fmpz_poly_set_str(fmpz_poly_mat_entry(sr->sk, i, j), str);
}
}
ss->next = sr;
ss = sr;
}
ss->next = NULL;
fclose(fp);
sh = sh->next;
while(lev > ctlev){
sh = sh->next;
param = param->next;
lev--;
}
fmpz_poly_t ms;
fmpz_poly_init(ms);
e_decrypt(ms, param, sh->sk, ct, fx);
fmpz_poly_print(ms);
printf("\n");
return 0;
}
