void
_acb_poly_binomial_transform_basecase(acb_ptr b, acb_srcptr a, slong alen, slong len, slong prec)
{
slong n, k;
fmpz_t t;
fmpz_init(t);
for (n = 0; n < len; n++)
{
acb_zero(b + n);
for (k = 0; k < FLINT_MIN(n + 1, alen); k++)
{
if (k == 0)
{
fmpz_one(t);
}
else
{
fmpz_mul_si(t, t, -(n - k + 1));
fmpz_divexact_ui(t, t, k);
}
acb_addmul_fmpz(b + n, a + k, t, prec);
}
}
fmpz_clear(t);
}
static void
_padic_log_bsplit_series(fmpz_t P, fmpz_t B, fmpz_t T,
const fmpz_t x, long a, long b)
{
if (b - a == 1)
{
fmpz_set(P, x);
fmpz_set_si(B, a);
fmpz_set(T, x);
}
else if (b - a == 2)
{
fmpz_mul(P, x, x);
fmpz_set_si(B, a);
fmpz_mul_si(B, B, a + 1);
fmpz_mul_si(T, x, a + 1);
fmpz_addmul_ui(T, P, a);
}
else
{
const long m = (a + b) / 2;
fmpz_t RP, RB, RT;
_padic_log_bsplit_series(P, B, T, x, a, m);
fmpz_init(RP);
fmpz_init(RB);
fmpz_init(RT);
_padic_log_bsplit_series(RP, RB, RT, x, m, b);
fmpz_mul(RT, RT, P);
fmpz_mul(T, T, RB);
fmpz_addmul(T, RT, B);
fmpz_mul(P, P, RP);
fmpz_mul(B, B, RB);
fmpz_clear(RP);
fmpz_clear(RB);
fmpz_clear(RT);
}
}
int main()
{
printf("seq_set_fmpq_pow....");
fflush(stdout);
{
long i;
fmpq_t t, u;
fmpz_holonomic_t op;
fmpq_t c, initial;
fmpz_holonomic_init(op);
fmpq_init(t);
fmpq_init(u);
fmpq_init(c);
fmpq_init(initial);
fmpq_set_si(c, -7, 3);
fmpz_holonomic_seq_set_fmpq_pow(op, c);
fmpq_set_si(initial, -2, 1);
for (i = 0; i < 20; i++)
{
fmpz_holonomic_get_nth_fmpq(t, op, initial, 0, i);
fmpz_pow_ui(fmpq_numref(u), fmpq_numref(c), i);
fmpz_pow_ui(fmpq_denref(u), fmpq_denref(c), i);
fmpz_mul_si(fmpq_numref(u), fmpq_numref(u), -2);
if (!fmpq_equal(t, u))
{
printf("FAIL\n");
printf("i = %ld, t = ", i); fmpq_print(t);
printf(" u = "); fmpq_print(u);
printf("\n");
abort();
}
}
fmpq_clear(c);
fmpq_clear(t);
fmpq_clear(u);
fmpq_clear(initial);
fmpz_holonomic_clear(op);
}
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void _fmpq_poly_scalar_div_si(fmpz * rpoly, fmpz_t rden, const fmpz * poly,
const fmpz_t den, long len, long c)
{
if (c == 1)
{
if (rpoly != poly)
{
_fmpz_vec_set(rpoly, poly, len);
fmpz_set(rden, den);
}
}
else if (c == -1)
{
_fmpz_vec_neg(rpoly, poly, len);
fmpz_set(rden, den);
}
else
{
fmpz_t d, f;
fmpz_init(d);
fmpz_init(f);
fmpz_set_si(f, c);
_fmpz_vec_content(d, poly, len);
fmpz_gcd(d, d, f);
if (c > 0)
{
_fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, d);
fmpz_mul_si(rden, den, c / fmpz_get_si(d));
}
else
{
ulong q = (- (ulong) c) / fmpz_get_ui(d);
fmpz_neg(d, d);
_fmpz_vec_scalar_divexact_fmpz(rpoly, poly, len, d);
fmpz_mul_ui(rden, den, q);
}
fmpz_clear(d);
fmpz_clear(f);
}
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("divexact_si....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, c;
mpz_t e, f, g;
slong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = z_randtest_not_zero(state);
fmpz_mul_si(c, a, n);
fmpz_get_mpz(e, c);
fmpz_divexact_si(a, c, n);
flint_mpz_divexact_ui(f, e, FLINT_ABS(n));
if (n < 0)
mpz_neg(f, f);
fmpz_get_mpz(g, a);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("n = %wd, e = %Zd, f = %Zd, g = %Zd\n", n, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Test aliasing of a and c */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, c;
mpz_t d, f, g;
slong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(d);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = z_randtest_not_zero(state);
fmpz_mul_si(c, a, n);
fmpz_get_mpz(d, c);
fmpz_divexact_si(c, c, n);
flint_mpz_divexact_ui(f, d, FLINT_ABS(n));
if (n < 0)
mpz_neg(f, f);
fmpz_get_mpz(g, c);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL;\n");
gmp_printf("d = %Zd, n = %wd, f = %Zd, g = %Zd\n", d, n, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(f);
mpz_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(int argc, char *argv[])
{
ulong r, s, p, prec, s_prec;
ulong i, m, lambda, char1, char2;
fmpz_poly_t eis, eta, eta_r;
fmpz_t p1, c1, c2, ss1, ss, pp, ppl, pplc;
// input r, s, and the precision desired
if (argc == 4) {
r = atol(argv[1]);
s = atol(argv[2]);
prec = atol(argv[3]);
prec = n_nextprime(prec, 1) - 1;
}
if (argc != 4) {
printf("usage: shimura_coeffs r s n\n");
return EXIT_FAILURE;
}
// Compute the weight of the form f_r_s
lambda = r / 2 + s;
//printf("%d\n", lambda);
// This is the necessary precision of the input
s_prec = (prec + r) * prec * r / 24;
//printf("Necessary precision: %d terms\n", s_prec);
// First compute eta
//printf("Computing eta\n");
fmpz_poly_init(eta);
eta_series(&eta, s_prec);
// Next compute eta^r
//printf("Computing eta^%d\n", r);
fmpz_poly_init(eta_r);
fmpz_poly_pow_trunc(eta_r, eta, r, s_prec);
fmpz_poly_clear(eta);
// Next compute E_s
//printf("Computing E_%d\n", s);
fmpz_poly_init(eis);
if(s != 0) {
eis_series(&eis, s, s_prec);
}
//printf("Computing coefficients\n");
// Instead of computing the product, we will compute each coefficient as
// needed. This is potentially slower, but saves memory.
//
fmpz_init(p1);
fmpz_init(c1);
fmpz_init(c2);
fmpz_init(ss);
fmpz_init(ss1);
// compute alpha(p^2*r)
p = 2;
m = r*p*p;
while(p <= prec) {
fmpz_set_ui(ss1, 0);
if(s != 0) {
for(i = r; i <= m; i += 24) {
if((m - i) % 24 == 0) {
fmpz_poly_get_coeff_fmpz(c1, eta_r, (i - r) / 24);
fmpz_poly_get_coeff_fmpz(c2, eis, (m - i) / 24);
fmpz_addmul(ss1, c1, c2);
}
}
}
else {
if((m - r) % 24 == 0)
fmpz_poly_get_coeff_fmpz(ss1, eta_r, (m - r) / 24);
}
/*
if(p == 199) {
fmpz_print(ss1);
printf("\n");
}
*/
// compute character X12(p)
char1 = n_jacobi(12, p);
// compute character ((-1)^(lambda) * n | p)
if(lambda % 2 == 0) {
char2 = n_jacobi(r, p);
}
else {
char2 = n_jacobi(-r, p);
}
// compute p^(lambda - 1)
fmpz_set_ui(pp, p);
fmpz_pow_ui(ppl, pp, lambda - 1);
fmpz_mul_si(pplc, ppl, char1*char2);
fmpz_add(ss, ss1, pplc);
printf("%d:\t", p);
fmpz_print(ss);
printf("\n");
p = n_nextprime(p, 1);
m = r*p*p;
}
fmpz_clear(p1);
fmpz_clear(c1);
fmpz_clear(c2);
fmpz_clear(ss);
fmpz_clear(ss1);
return EXIT_SUCCESS;
}
static void
_qadic_exp_bsplit_series(fmpz *P, fmpz_t Q, fmpz *T,
const fmpz *x, slong len, slong lo, slong hi,
const fmpz *a, const slong *j, slong lena)
{
const slong d = j[lena - 1];
if (hi - lo == 1)
{
_fmpz_vec_set(P, x, len);
_fmpz_vec_zero(P + len, 2*d - 1 - len);
fmpz_set_si(Q, lo);
_fmpz_vec_set(T, P, 2*d - 1);
}
else if (hi - lo == 2)
{
_fmpz_poly_sqr(P, x, len);
_fmpz_vec_zero(P + (2*len - 1), d - (2*len - 1));
_fmpz_poly_reduce(P, 2*len - 1, a, j, lena);
fmpz_set_si(Q, lo);
fmpz_mul_si(Q, Q, lo + 1);
_fmpz_vec_scalar_mul_si(T, x, len, lo + 1);
_fmpz_vec_zero(T + len, d - len);
_fmpz_vec_add(T, T, P, d);
}
else
{
const slong m = (lo + hi) / 2;
fmpz *PR, *TR, *W;
fmpz_t QR;
PR = _fmpz_vec_init(2*d - 1);
TR = _fmpz_vec_init(2*d - 1);
W = _fmpz_vec_init(2*d - 1);
fmpz_init(QR);
_qadic_exp_bsplit_series(P, Q, T, x, len, lo, m, a, j, lena);
_qadic_exp_bsplit_series(PR, QR, TR, x, len, m, hi, a, j, lena);
_fmpz_poly_mul(W, TR, d, P, d);
_fmpz_poly_reduce(W, 2*d - 1, a, j, lena);
_fmpz_vec_scalar_mul_fmpz(T, T, d, QR);
_fmpz_vec_add(T, T, W, d);
_fmpz_poly_mul(W, P, d, PR, d);
_fmpz_poly_reduce(W, 2*d - 1, a, j, lena);
_fmpz_vec_swap(P, W, d);
fmpz_mul(Q, Q, QR);
_fmpz_vec_clear(PR, 2*d - 1);
_fmpz_vec_clear(TR, 2*d - 1);
_fmpz_vec_clear(W, 2*d - 1);
fmpz_clear(QR);
}
}
int
_fmpz_poly_sqrt_classical(fmpz * res, const fmpz * poly, long len)
{
long i, m;
int result;
/* the degree must be even */
if (len % 2 == 0)
return 0;
/* valuation must be even, and then can be reduced to 0 */
while (fmpz_is_zero(poly))
{
if (!fmpz_is_zero(poly + 1))
return 0;
fmpz_zero(res);
poly += 2;
len -= 2;
res++;
}
/* check whether a square root exists modulo 2 */
for (i = 1; i < len; i += 2)
if (!fmpz_is_even(poly + i))
return 0;
/* check endpoints */
if (!fmpz_is_square(poly) || (len > 1 && !fmpz_is_square(poly + len - 1)))
return 0;
/* square root of leading coefficient */
m = (len + 1) / 2;
fmpz_sqrt(res + m - 1, poly + len - 1);
result = 1;
/* do long divison style 'square root with remainder' from top to bottom */
if (len > 1)
{
fmpz_t t, u;
fmpz * r;
fmpz_init(t);
fmpz_init(u);
r = _fmpz_vec_init(len);
_fmpz_vec_set(r, poly, len);
fmpz_mul_ui(u, res + m - 1, 2);
for (i = 1; i < m; i++)
{
fmpz_fdiv_qr(res + m - i - 1, t, r + len - i - 1, u);
if (!fmpz_is_zero(t))
{
result = 0;
break;
}
fmpz_mul_si(t, res + m - i - 1, -2);
_fmpz_vec_scalar_addmul_fmpz(r + len - 2*i, res + m - i, i - 1, t);
fmpz_submul(r + len - 2*i - 1, res + m - i - 1, res + m - i - 1);
}
for (i = m; i < len && result; i++)
if (!fmpz_is_zero(r + len - 1 - i))
result = 0;
_fmpz_vec_clear(r, len);
fmpz_clear(t);
fmpz_clear(u);
}
return result;
}
