void fmpz_addmul(fmpz_t res, const fmpz_t a, const fmpz_t b)
{
long a0 = a[0];
long b0 = b[0];
unsigned long sizea = FLINT_ABS(a0);
unsigned long sizeb = FLINT_ABS(b0);
while ((!a[sizea]) && (sizea)) sizea--;
while ((!b[sizeb]) && (sizeb)) sizeb--;
fmpz_t temp;
mp_limb_t mslimb;
if (sizea && sizeb)
{
if (sizea + sizeb < 100)
{
temp = (fmpz_t) flint_stack_alloc_small(sizea + sizeb + 1);
if (sizea >= sizeb) mslimb = mpn_mul(temp+1, a+1, sizea, b+1, sizeb);
else mslimb = mpn_mul(temp+1, b+1, sizeb, a+1, sizea);
temp[0] = sizea + sizeb - (mslimb == 0);
if ((long) (a[0] ^ b[0]) < 0) temp[0] = -temp[0];
fmpz_add(res, res, temp);
flint_stack_release_small();
} else
{
temp = (fmpz_t) flint_stack_alloc(sizea + sizeb + 1);
if (sizea >= sizeb) mslimb = F_mpn_mul(temp+1, a+1, sizea, b+1, sizeb);
else mslimb = F_mpn_mul(temp+1, b+1, sizeb, a+1, sizea);
temp[0] = sizea + sizeb - (mslimb == 0);
if ((long) (a[0] ^ b[0]) < 0) temp[0] = -temp[0];
fmpz_add(res, res, temp);
flint_stack_release();
}
}
}
void
elem_add(elem_ptr res, elem_srcptr op1, elem_srcptr op2, const ring_t ring)
{
switch (ring->type)
{
case TYPE_FMPZ:
fmpz_add(res, op1, op2);
break;
case TYPE_LIMB:
*((mp_ptr) res) = *((mp_srcptr) op1) + *((mp_srcptr) op2);
break;
case TYPE_POLY:
elem_poly_add(res, op1, op2, ring);
break;
case TYPE_MOD:
{
switch (RING_PARENT(ring)->type)
{
case TYPE_LIMB:
*((mp_ptr) res) = n_addmod(*((mp_srcptr) op1), *((mp_srcptr) op2), ring->nmod.n);
break;
case TYPE_FMPZ:
fmpz_add(res, op1, op2);
if (fmpz_cmpabs(res, RING_MODULUS(ring)) >= 0)
fmpz_sub(res, res, RING_MODULUS(ring));
break;
default:
NOT_IMPLEMENTED("add (mod)", ring);
}
}
break;
case TYPE_FRAC:
elem_frac_add(res, op1, op2, ring);
break;
case TYPE_COMPLEX:
elem_add(REALPART(res, ring), REALPART(op1, ring), REALPART(op2, ring), ring->parent);
elem_add(IMAGPART(res, ring), IMAGPART(op1, ring), IMAGPART(op2, ring), ring->parent);
break;
default:
NOT_IMPLEMENTED("add", ring);
}
}
void
_fmpz_poly_evaluate_horner_fmpz(fmpz_t res, const fmpz * f, long len,
const fmpz_t a)
{
if (len == 0)
{
fmpz_zero(res);
}
else if (len == 1 || fmpz_is_zero(a))
{
fmpz_set(res, f);
}
else
{
long i = len - 1;
fmpz_t t;
fmpz_init(t);
fmpz_set(res, f + i);
for (i = len - 2; i >= 0; i--)
{
fmpz_mul(t, res, a);
fmpz_add(res, f + i, t);
}
fmpz_clear(t);
}
}
void padic_val_fac(fmpz_t rop, const fmpz_t op, const fmpz_t p)
{
fmpz_t t, q, pow;
if (fmpz_sgn(op) <= 0)
{
printf("Exception (padic_val_fac). op is non-positive.\n");
abort();
}
fmpz_init(t);
fmpz_init(q);
fmpz_init(pow);
fmpz_one(pow);
do
{
fmpz_mul(pow, pow, p);
fmpz_fdiv_q(q, op, pow);
fmpz_add(t, t, q);
}
while (!fmpz_is_zero(q));
fmpz_swap(rop, t);
fmpz_clear(t);
fmpz_clear(q);
fmpz_clear(pow);
}
void _fmpz_mod_poly_evaluate_fmpz(fmpz_t res, const fmpz *poly, slong len,
const fmpz_t a, const fmpz_t p)
{
if (len == 0)
{
fmpz_zero(res);
}
else if (len == 1 || fmpz_is_zero(a))
{
fmpz_set(res, poly);
}
else
{
slong i = len - 1;
fmpz_t t;
fmpz_init(t);
fmpz_set(res, poly + i);
for (i = len - 2; i >= 0; i--)
{
fmpz_mul(t, res, a);
fmpz_mod(t, t, p);
fmpz_add(res, poly + i, t);
}
fmpz_clear(t);
if (fmpz_cmpabs(res, p) >= 0)
fmpz_sub(res, res, p);
}
}
void fmpz_invert(fmpz_t res, fmpz_t x, fmpz_t m)
{
if (m[0] == 0)
{
printf("Error: division by zero!\n");
abort();
}
fmpz_t s0, U, V, temp;
unsigned long size = fmpz_size(m);
// U may use fmpz_size(m) + 1 limbs after the sum, and gmp requires +1
U = fmpz_init(size + 2);
V = fmpz_init(size + 2);
s0 = fmpz_init(size + 2);
temp = fmpz_init(size + 2);
// U := (x%m) + abs(m)
// V := abs(m)
fmpz_abs(V, m);
fmpz_mod(U, x, V);
fmpz_add(U, U, V);
// Compute s0 such that 1 = s0 * x % m
mpn_gcdext(temp+1, s0+1, (long *) s0, U+1, fmpz_size(U), V+1, fmpz_size(V));
fmpz_mod(res, s0, m);
fmpz_clear(temp);
fmpz_clear(s0);
fmpz_clear(V);
fmpz_clear(U);
}
static void dsum_p(
fmpz_t rop,
const fmpz *dinv, const fmpz *mu, long M, const long *C, long lenC,
const fmpz_t a, long ui, long vi, long n, long d, long p, long N)
{
long m, r, idx;
fmpz_t apm1, apow, f, g, P, PN;
fmpz_init(apm1);
fmpz_init(apow);
fmpz_init(f);
fmpz_init(g);
fmpz_init_set_ui(P, p);
fmpz_init(PN);
fmpz_pow_ui(PN, P, N);
fmpz_zero(rop);
r = 0;
m = (p * (ui + 1) - (vi + 1)) / d;
if (m <= M) /* Step {r = 0} */
{
idx = _bsearch(C, 0, lenC, m % p);
fmpz_powm_ui(apm1, a, p - 1, PN);
fmpz_one(apow);
fmpz_one(f);
fmpz_mod(rop, mu + idx + lenC * (m / p), PN);
}
for (r = 1, m += p; m <= M; r++, m += p)
{
idx = _bsearch(C, 0, lenC, m % p);
fmpz_mul(apow, apow, apm1);
fmpz_mod(apow, apow, PN);
fmpz_mul_ui(f, f, ui + 1 + (r - 1) * d);
fmpz_mod(f, f, PN);
fmpz_mul(g, f, dinv + r);
fmpz_mul(g, g, apow);
fmpz_mul(g, g, mu + idx + lenC * (m / p));
fmpz_mod(g, g, PN);
fmpz_add(rop, rop, g);
}
fmpz_mod(rop, rop, PN);
fmpz_clear(apm1);
fmpz_clear(apow);
fmpz_clear(f);
fmpz_clear(g);
fmpz_clear(P);
fmpz_clear(PN);
}
slong
fmpr_add_naive(fmpr_t z, const fmpr_t x, const fmpr_t y, slong prec, fmpr_rnd_t rnd)
{
slong shift, xsize, ysize;
if (fmpr_is_special(x) || fmpr_is_special(y))
{
return _fmpr_add_special(z, x, y, prec, rnd);
}
shift = _fmpz_sub_small(fmpr_expref(x), fmpr_expref(y));
if (shift == 0)
{
fmpz_add(fmpr_manref(z), fmpr_manref(x), fmpr_manref(y));
fmpz_set(fmpr_expref(z), fmpr_expref(x));
}
else if (shift > 0)
{
ysize = _fmpz_size(fmpr_manref(y)) * FLINT_BITS;
/* x and y do not overlap */
if (shift > ysize && prec != FMPR_PREC_EXACT)
{
/* y does not overlap with result */
if (ysize + prec - (slong) fmpz_bits(fmpr_manref(x)) < shift)
{
return _fmpr_add_eps(z, x, fmpz_sgn(fmpr_manref(y)), prec, rnd);
}
}
fmpz_add_mul2exp(fmpr_manref(z), fmpr_manref(y), fmpr_manref(x), shift);
fmpz_set(fmpr_expref(z), fmpr_expref(y));
}
else
{
shift = -shift;
xsize = _fmpz_size(fmpr_manref(x)) * FLINT_BITS;
/* x and y do not overlap */
if (shift > xsize && prec != FMPR_PREC_EXACT)
{
/* y does not overlap with result */
if (xsize + prec - (slong) fmpz_bits(fmpr_manref(y)) < shift)
{
return _fmpr_add_eps(z, y, fmpz_sgn(fmpr_manref(x)), prec, rnd);
}
}
fmpz_add_mul2exp(fmpr_manref(z), fmpr_manref(x), fmpr_manref(y), shift);
fmpz_set(fmpr_expref(z), fmpr_expref(x));
}
return _fmpr_normalise(fmpr_manref(z), fmpr_expref(z), prec, rnd);
}
void
_fmpz_poly_pseudo_divrem_cohen(fmpz * Q, fmpz * R, const fmpz * A,
long lenA, const fmpz * B, long lenB)
{
const fmpz * leadB = B + (lenB - 1);
long e, lenQ;
fmpz_t pow;
if (lenB == 1)
{
fmpz_init(pow);
fmpz_pow_ui(pow, leadB, lenA - 1);
_fmpz_vec_scalar_mul_fmpz(Q, A, lenA, pow);
_fmpz_vec_zero(R, lenA);
fmpz_clear(pow);
return;
}
lenQ = lenA - lenB + 1;
_fmpz_vec_zero(Q, lenQ);
if (R != A)
_fmpz_vec_set(R, A, lenA);
e = lenA - lenB;
/* Unroll the first run of the while loop */
{
fmpz_set(Q + (lenQ - 1), R + (lenA - 1));
_fmpz_vec_scalar_mul_fmpz(R, R, lenA - 1, leadB);
_fmpz_vec_scalar_submul_fmpz(R + (lenA - lenB), B, lenB - 1, R + (lenA - 1));
fmpz_zero(R + (lenA - 1));
for (lenA -= 2; (lenA >= 0) && (R[lenA] == 0L); lenA--) ;
lenA++;
}
while (lenA >= lenB)
{
_fmpz_vec_scalar_mul_fmpz(Q, Q, lenQ, leadB);
fmpz_add(Q + (lenA - lenB), Q + (lenA - lenB), R + (lenA - 1));
_fmpz_vec_scalar_mul_fmpz(R, R, lenA - 1, leadB);
_fmpz_vec_scalar_submul_fmpz(R + lenA - lenB, B, lenB - 1, R + (lenA - 1));
fmpz_zero(R + (lenA - 1));
for (lenA -= 2; (lenA >= 0) && (R[lenA] == 0L); lenA--) ;
lenA++;
e--;
}
fmpz_init(pow);
fmpz_pow_ui(pow, leadB, e);
_fmpz_vec_scalar_mul_fmpz(Q, Q, lenQ, pow);
_fmpz_vec_scalar_mul_fmpz(R, R, lenA, pow);
fmpz_clear(pow);
}
void
_fmpz_vec_scalar_addmul_si_2exp(fmpz * vec1, const fmpz * vec2, slong len2,
slong c, ulong exp)
{
slong i;
fmpz_t temp;
if (c == 0)
return; /* nothing to add */
if (exp == 0) /* just do addmul */
{
_fmpz_vec_scalar_addmul_si(vec1, vec2, len2, c);
return;
}
fmpz_init(temp);
if (c == 1) /* scalar is 1, just add c * 2^exp times c */
{
for (i = 0; i < len2; i++)
{
fmpz_mul_2exp(temp, vec2 + i, exp);
fmpz_add(vec1 + i, vec1 + i, temp);
}
}
else if (c == -1) /* scalar is -1, subtract c * 2^exp */
{
for (i = 0; i < len2; i++)
{
fmpz_mul_2exp(temp, vec2 + i, exp);
fmpz_sub(vec1 + i, vec1 + i, temp);
}
}
else /* generic case */
{
if (c > 0)
{
for (i = 0; i < len2; i++)
{
fmpz_mul_2exp(temp, vec2 + i, exp);
fmpz_addmul_ui(vec1 + i, temp, c);
}
}
else
{
for (i = 0; i < len2; i++)
{
fmpz_mul_2exp(temp, vec2 + i, exp);
fmpz_submul_ui(vec1 + i, temp, -c);
}
}
}
fmpz_clear(temp);
}
/* in1 += x*in2 assuming both in1 and in2 are revbin'd. */
void
_fmpz_vec_add_rev(fmpz * in1, fmpz * in2, long bits)
{
long i;
for (i = 0; i < (1L << bits) - 1; i++)
{
long j = n_revbin(n_revbin(i, bits) + 1, bits);
fmpz_add(in1 + j, in1 + j, in2 + i);
}
}
void
_fmprb_get_rand_fmpq(fmpz_t num, fmpz_t den, flint_rand_t state,
const fmpz_t den_mult, const fmprb_t x)
{
fmpz_t a, b, exp;
fmpz_init(a);
fmpz_init(b);
fmpz_init(exp);
fmprb_get_interval_fmpz_2exp(a, b, exp, x);
if (COEFF_IS_MPZ(*exp))
{
printf("exception: fmprb_get_rand_fmpq: too large exponent\n");
abort();
}
if (*exp >= 0)
{
fmpz_mul_2exp(a, a, *exp);
fmpz_mul_2exp(b, b, *exp);
}
/* generate random integer in [a*den, b*den] */
fmpz_mul(a, a, den_mult);
fmpz_mul(b, b, den_mult);
fmpz_add_ui(b, b, 1UL);
fmpz_sub(b, b, a);
/* return one endpoint with high probability (used for stress
testing rounding) */
if (n_randint(state, 6) == 0)
{
if (n_randint(state, 2))
fmpz_zero(num);
else
fmpz_sub_ui(num, b, 1UL);
}
else
{
fmpz_randtest_mod(num, state, b);
}
fmpz_add(num, num, a);
fmpz_set(den, den_mult);
if (*exp < 0)
fmpz_mul_2exp(den, den, -(*exp));
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(exp);
}
void
poly_starmultiply(fmpz_poly_t c,
const fmpz_poly_t a,
const fmpz_poly_t b,
const ntru_params *params,
uint32_t modulus)
{
fmpz_poly_t a_tmp;
fmpz_t c_coeff_k;
fmpz_poly_init(a_tmp);
fmpz_init(c_coeff_k);
/* avoid side effects */
fmpz_poly_set(a_tmp, a);
fmpz_poly_zero(c);
for (int k = params->N - 1; k >= 0; k--) {
int j;
j = k + 1;
fmpz_set_si(c_coeff_k, 0);
for (int i = params->N - 1; i >= 0; i--) {
fmpz *a_tmp_coeff_i,
*b_coeff_j;
if (j == (int)(params->N))
j = 0;
a_tmp_coeff_i = fmpz_poly_get_coeff_ptr(a_tmp, i);
b_coeff_j = fmpz_poly_get_coeff_ptr(b, j);
if (fmpz_cmp_si_n(a_tmp_coeff_i, 0) &&
fmpz_cmp_si_n(b_coeff_j, 0)) {
fmpz_t fmpz_tmp;
fmpz_init(fmpz_tmp);
fmpz_mul(fmpz_tmp, a_tmp_coeff_i, b_coeff_j);
fmpz_add(fmpz_tmp, fmpz_tmp, c_coeff_k);
fmpz_mod_ui(c_coeff_k, fmpz_tmp, modulus);
fmpz_poly_set_coeff_fmpz(c, k, c_coeff_k);
fmpz_clear(fmpz_tmp);
}
j++;
}
fmpz_clear(c_coeff_k);
}
fmpz_poly_clear(a_tmp);
}
void _fmpz_mod_poly_sub(fmpz *res, const fmpz *poly1, long len1,
const fmpz *poly2, long len2, const fmpz_t p)
{
long i, len = FLINT_MAX(len1, len2);
_fmpz_poly_sub(res, poly1, len1, poly2, len2);
for (i = 0; i < len; i++)
{
if (fmpz_sgn(res + i) < 0)
fmpz_add(res + i, res + i, p);
}
}
static void
bsplit(arb_t y, const fmpz_t p, const fmpz_t q, ulong a, ulong b, long prec)
{
if (b - a <= 8)
{
fmpz_t t, u;
ulong c;
fmpz_init(t);
fmpz_init(u);
fmpz_mul_ui(t, q, a);
fmpz_add(t, t, p);
fmpz_set(u, t);
for (c = a + 1; c < b; c++)
{
fmpz_add(u, u, q);
fmpz_mul(t, t, u);
}
arb_set_round_fmpz(y, t, prec);
fmpz_clear(t);
fmpz_clear(u);
}
else
{
arb_t w;
ulong m = a + (b - a) / 2;
arb_init(w);
bsplit(y, p, q, a, m, prec);
bsplit(w, p, q, m, b, prec);
arb_mul(y, y, w, prec);
arb_clear(w);
}
}
void
_fmpq_bsplit_sum_abpq(fmpz_t P, fmpz_t Q, fmpz_t B, fmpz_t T,
const fmpq * ab, const fmpq * pq, long n1, long n2)
{
if (n2 - n1 <= 0)
{
fmpz_zero(P);
fmpz_one(Q);
}
else if (n2 - n1 == 1)
{
fmpz_set(P, fmpq_numref(pq + n1));
fmpz_set(Q, fmpq_denref(pq + n1));
fmpz_set(B, fmpq_denref(ab + n1));
fmpz_mul(T, P, fmpq_numref(ab + n1));
}
else
{
long m = (n1 + n2) / 2;
fmpz_t P2, Q2, B2, T2;
fmpz_init(P2);
fmpz_init(Q2);
fmpz_init(B2);
fmpz_init(T2);
_fmpq_bsplit_sum_abpq(P, Q, B, T, ab, pq, n1, m);
_fmpq_bsplit_sum_abpq(P2, Q2, B2, T2, ab, pq, m, n2);
if (!fmpz_is_one(B2))
fmpz_mul(T, T, B2);
fmpz_mul(T, T, Q2);
if (!fmpz_is_one(B))
fmpz_mul(T2, T2, B);
fmpz_mul(T2, T2, P);
fmpz_add(T, T, T2);
fmpz_mul(P, P, P2);
fmpz_mul(Q, Q, Q2);
fmpz_mul(B, B, B2);
fmpz_clear(P2);
fmpz_clear(Q2);
fmpz_clear(B2);
fmpz_clear(T2);
}
}
void
fmpz_mat_trace(fmpz_t trace, const fmpz_mat_t mat)
{
slong i, n = fmpz_mat_nrows(mat);
if (n == 0)
fmpz_zero(trace);
else
{
fmpz_set(trace, fmpz_mat_entry(mat, 0, 0));
for (i = 1; i < n; i++)
fmpz_add(trace, trace, fmpz_mat_entry(mat, i, i));
}
}
void
fmpz_add_n(fmpz_t f, const fmpz_t g, const fmpz_t h)
{
if (!g && !h) {
fmpz_zero(f);
} else {
if (!g && h)
fmpz_add_ui(f, h, 0);
else if (g && !h)
fmpz_add_ui(f, g, 0);
else
fmpz_add(f, g, h);
}
}
void
_gamma_rf_bsplit(fmpz * A, ulong a, ulong b)
{
ulong n = b - a;
if (n == 0)
{
fmpz_one(A);
}
else if (n < 8)
{
ulong j, k;
fmpz_set_ui(A, a);
fmpz_one(A + 1);
for (j = 1; j < n; j++)
{
fmpz_one(A + j + 1);
for (k = j; k > 0; k--)
{
fmpz_mul_ui(A + k, A + k, a + j);
fmpz_add(A + k, A + k, A + k - 1);
}
fmpz_mul_ui(A, A, a + j);
}
}
else
{
ulong m = a + (b - a) / 2;
ulong w = m - a;
ulong v = b - m;
fmpz *t, *A1, *A2;
t = _fmpz_vec_init(w + v + 2);
A1 = t;
A2 = A1 + w + 1;
_gamma_rf_bsplit(A1, a, m);
_gamma_rf_bsplit(A2, m, b);
_fmpz_poly_mul(A, A2, v + 1, A1, w + 1);
_fmpz_vec_clear(t, w + v + 2);
}
}
void
_arb_poly_get_scale(fmpz_t scale, arb_srcptr x, slong xlen,
arb_srcptr y, slong ylen)
{
slong xa, xb, ya, yb, den;
fmpz_zero(scale);
/* ignore zeros (and infs/nans!); find the first and last
finite nonzero entries to determine the scale */
xa = 0;
xb = xlen - 1;
while (xa < xlen && arf_is_special(arb_midref(x + xa))) xa++;
while (xb > xa && arf_is_special(arb_midref(x + xb))) xb--;
ya = 0;
yb = ylen - 1;
while (ya < ylen && arf_is_special(arb_midref(y + ya))) ya++;
while (yb > ya && arf_is_special(arb_midref(y + yb))) yb--;
/* compute average of exponent differences, weighted by the lengths */
if (xa <= xb && ya <= yb && (xa < xb || ya < yb))
{
fmpz_add(scale, scale, ARF_EXPREF(arb_midref(x + xb)));
fmpz_sub(scale, scale, ARF_EXPREF(arb_midref(x + xa)));
fmpz_add(scale, scale, ARF_EXPREF(arb_midref(y + yb)));
fmpz_sub(scale, scale, ARF_EXPREF(arb_midref(y + ya)));
den = (xb - xa) + (yb - ya);
/* scale = floor(scale / den + 1/2) = floor((2 scale + den) / (2 den)) */
fmpz_mul_2exp(scale, scale, 1);
fmpz_add_ui(scale, scale, den);
fmpz_fdiv_q_ui(scale, scale, 2 * den);
}
}
int
main(void)
{
long i, n;
fmpz_t x, y, z, w;
printf("fib_ui....");
fflush(stdout);
fmpz_init(x);
fmpz_init(y);
fmpz_init(z);
fmpz_init(w);
/* Twice to check demotion */
for (n = 0; n < 2; n++)
{
for (i = 0; i < 200; i++)
{
fmpz_fib_ui(x, i);
fmpz_fib_ui(y, i+1);
fmpz_fib_ui(z, i+2);
fmpz_add(w, x, y);
if (!fmpz_equal(w, z))
{
printf("FAIL: %ld\n", i);
fmpz_print(x);
printf("\n");
fmpz_print(y);
printf("\n");
fmpz_print(z);
printf("\n");
abort();
}
}
}
fmpz_clear(x);
fmpz_clear(y);
fmpz_clear(z);
fmpz_clear(w);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
_fmpz_poly_pow_multinomial(fmpz * res, const fmpz * poly, long len, ulong e)
{
long k, low, rlen;
fmpz_t d, t;
fmpz * P;
rlen = (long) e * (len - 1L) + 1L;
_fmpz_vec_zero(res, rlen);
for (low = 0L; poly[low] == 0L; low++) ;
if (low == 0L)
{
P = (fmpz *) poly;
}
else
{
P = (fmpz *) poly + low;
len -= low;
res += (long) e * low;
rlen -= (long) e * low;
}
fmpz_init(d);
fmpz_init(t);
fmpz_pow_ui(res, P, e);
for (k = 1; k < rlen; k++)
{
long i, u = -k;
for (i = 1; i <= FLINT_MIN(k, len - 1); i++)
{
fmpz_mul(t, P + i, res + (k - i));
u += (long) e + 1;
if (u >= 0)
fmpz_addmul_ui(res + k, t, (ulong) u);
else
fmpz_submul_ui(res + k, t, - ((ulong) u));
}
fmpz_add(d, d, P);
fmpz_divexact(res + k, res + k, d);
}
fmpz_clear(d);
fmpz_clear(t);
}
void arith_stirling_number_2_vec_next(fmpz * row,
const fmpz * prev, slong n, slong klen)
{
slong k;
if (klen > n) fmpz_one(row + n);
if (n != 0 && klen != 0) fmpz_zero(row);
for (k = FLINT_MIN(n, klen) - 1; k >= 1; k--)
{
fmpz_mul_ui(row + k, prev + k, k);
fmpz_add(row + k, prev + k - 1, row + k);
}
for (k = n + 1; k < klen; k++)
fmpz_zero(row + k);
}
mpz_class renf_elem_class::ceil() const noexcept
{
fmpz_t tmp;
fmpz_init(tmp);
if (nf == nullptr)
{
fmpz_add(tmp, fmpq_numref(b), fmpq_denref(b));
fmpz_sub_ui(tmp, tmp, 1);
fmpz_fdiv_q(tmp, tmp, fmpq_denref(b));
}
else
renf_elem_ceil(tmp, a, nf->renf_t());
mpz_class z;
fmpz_get_mpz(z.get_mpz_t(), tmp);
fmpz_clear(tmp);
return z;
}
static void
_qadic_exp_bsplit(fmpz *y, const fmpz *x, slong v, slong len,
const fmpz *a, const slong *j, slong lena,
const fmpz_t p, slong N)
{
const slong d = j[lena - 1];
const slong n = _padic_exp_bound(v, N, p);
if (n == 1)
{
fmpz_one(y + 0);
_fmpz_vec_zero(y + 1, d - 1);
}
else
{
fmpz *P, *T;
fmpz_t Q, R;
slong f;
P = _fmpz_vec_init(2*d - 1);
T = _fmpz_vec_init(2*d - 1);
fmpz_init(Q);
fmpz_init(R);
_qadic_exp_bsplit_series(P, Q, T, x, len, 1, n, a, j, lena);
fmpz_add(T + 0, T + 0, Q); /* (T,Q) := (T,Q) + 1 */
/* Note exp(x) is a unit so val(T) == val(Q). */
f = fmpz_remove(Q, Q, p);
fmpz_pow_ui(R, p, f);
_fmpz_vec_scalar_divexact_fmpz(T, T, d, R);
_padic_inv(Q, Q, p, N);
_fmpz_vec_scalar_mul_fmpz(y, T, d, Q);
_fmpz_vec_clear(P, 2*d - 1);
_fmpz_vec_clear(T, 2*d - 1);
fmpz_clear(Q);
fmpz_clear(R);
}
}
void
_fmpq_bsplit_sum_pq(fmpz_t P, fmpz_t Q, fmpz_t T,
const fmpq * pq, long n1, long n2)
{
if (n2 - n1 <= 0)
{
fmpz_zero(P);
fmpz_one(Q);
}
else if (n2 - n1 == 1)
{
fmpz_set(P, fmpq_numref(pq + n1));
fmpz_set(Q, fmpq_denref(pq + n1));
fmpz_set(T, P);
}
else
{
long m = (n1 + n2) / 2;
fmpz_t P2, Q2, T2;
fmpz_init(P2);
fmpz_init(Q2);
fmpz_init(T2);
_fmpq_bsplit_sum_pq(P, Q, T, pq, n1, m);
_fmpq_bsplit_sum_pq(P2, Q2, T2, pq, m, n2);
fmpz_mul(T, T, Q2);
fmpz_mul(T2, T2, P);
fmpz_add(T, T, T2);
fmpz_mul(P, P, P2);
fmpz_mul(Q, Q, Q2);
fmpz_clear(P2);
fmpz_clear(Q2);
fmpz_clear(T2);
}
}
void
test0(slong b)
{
fmpz_t M; fmpz_init_set_ui(M,1);
fmpz_mul_2exp(M,M,(ulong)b);
test1_ui(b,M,0);
test1_ui(b,M,1);
test1_ui(b,M,(mp_limb_t)-1);
test1(b,M,M); // M
fmpz_t n; fmpz_init_set(n,M);
fmpz_add_ui(n,M,1);
test1(b,M,n); // M+1
fmpz_sub_ui(n,M,1);
test1(b,M,n); // M-1
slong i;
fmpz_t m; fmpz_init(m);
fmpz_t Mhalf; fmpz_init(Mhalf);
fmpz_fdiv_q_2exp(Mhalf,M,1);
for(i=100;i--;)
{
fmpz_randm(m,rst,n); // m = random(M-1)
test1(b,M,m);
fmpz_add(m,m,Mhalf); // m+M/2
test1(b,M,m);
}
fmpz_mul_2exp(m,M,1);
test1(b,M,m); // M<<1
fmpz_mul_2exp(m,m,1);
test1(b,M,m); // M<<2
fmpz_mul_2exp(m,m,1);
test1(b,M,m); // M<<3
fmpz_mul(m,m,M);
test1(b,M,m); // M*(M<<3)
fmpz_clear(Mhalf);
fmpz_clear(m);
fmpz_clear(n);
fmpz_clear(M);
}
void _fmpz_mod_poly_compose_horner(fmpz *res, const fmpz *poly1, long len1,
const fmpz *poly2, long len2,
const fmpz_t p)
{
if (len1 == 1 || len2 == 0)
{
fmpz_set(res, poly1);
}
else
{
const long alloc = (len1 - 1) * (len2 - 1) + 1;
long i = len1 - 1, lenr = len2;
fmpz * t = _fmpz_vec_init(alloc);
/*
Perform the first two steps as one,
"res = a(m) * poly2 + a(m-1)".
*/
{
_fmpz_mod_poly_scalar_mul_fmpz(res, poly2, len2, poly1 + i, p);
i--;
fmpz_add(res, res, poly1 + i);
if (fmpz_cmpabs(res, p) >= 0)
fmpz_sub(res, res, p);
}
while (i > 0)
{
i--;
_fmpz_mod_poly_mul(t, res, lenr, poly2, len2, p);
lenr += len2 - 1;
_fmpz_mod_poly_add(res, t, lenr, poly1 + i, 1, p);
}
_fmpz_vec_clear(t, alloc);
}
}
/* Balanced product of linear factors (x+alpha_i) using
fixed-point arithmetic with prec bits */
static void
balanced_product(fmpz * c, fmpz * alpha, slong len, slong prec)
{
if (len == 1)
{
fmpz_one(c + 1);
fmpz_mul_2exp(c + 1, c + 1, prec);
fmpz_set(c, alpha);
}
else if (len == 2)
{
fmpz_mul(c, alpha, alpha + 1);
fmpz_fdiv_q_2exp(c, c, prec);
fmpz_add(c + 1, alpha, alpha + 1);
fmpz_one(c + 2);
fmpz_mul_2exp(c + 2, c + 2, prec);
}
else
{
fmpz *L, *R;
slong i, m;
m = len / 2;
L = _fmpz_vec_init(len + 2);
R = L + m + 1;
balanced_product(L, alpha, m, prec);
balanced_product(R, alpha + m, len - m, prec);
_fmpz_poly_mul(c, R, len - m + 1, L, m + 1);
for (i = 0; i < len + 1; i++)
fmpz_fdiv_q_2exp(c + i, c + i, prec);
_fmpz_vec_clear(L, len + 2);
}
}
void
_fmpz_poly_compose_divconquer(fmpz * res, const fmpz * poly1, long len1,
const fmpz * poly2, long len2)
{
long i, j, k, n;
long *hlen, alloc, powlen;
fmpz *v, **h, *pow, *temp;
if (len1 == 1)
{
fmpz_set(res, poly1);
return;
}
if (len2 == 1)
{
_fmpz_poly_evaluate_fmpz(res, poly1, len1, poly2);
return;
}
if (len1 == 2)
{
_fmpz_poly_compose_horner(res, poly1, len1, poly2, len2);
return;
}
/* Initialisation */
hlen = (long *) malloc(((len1 + 1) / 2) * sizeof(long));
for (k = 1; (2 << k) < len1; k++) ;
hlen[0] = hlen[1] = ((1 << k) - 1) * (len2 - 1) + 1;
for (i = k - 1; i > 0; i--)
{
long hi = (len1 + (1 << i) - 1) / (1 << i);
for (n = (hi + 1) / 2; n < hi; n++)
hlen[n] = ((1 << i) - 1) * (len2 - 1) + 1;
}
powlen = (1 << k) * (len2 - 1) + 1;
alloc = 0;
for (i = 0; i < (len1 + 1) / 2; i++)
alloc += hlen[i];
v = _fmpz_vec_init(alloc + 2 * powlen);
h = (fmpz **) malloc(((len1 + 1) / 2) * sizeof(fmpz *));
h[0] = v;
for (i = 0; i < (len1 - 1) / 2; i++)
{
h[i + 1] = h[i] + hlen[i];
hlen[i] = 0;
}
hlen[(len1 - 1) / 2] = 0;
pow = v + alloc;
temp = pow + powlen;
/* Let's start the actual work */
for (i = 0, j = 0; i < len1 / 2; i++, j += 2)
{
if (poly1[j + 1] != 0L)
{
_fmpz_vec_scalar_mul_fmpz(h[i], poly2, len2, poly1 + j + 1);
fmpz_add(h[i], h[i], poly1 + j);
hlen[i] = len2;
}
else if (poly1[j] != 0L)
{
fmpz_set(h[i], poly1 + j);
hlen[i] = 1;
}
}
if ((len1 & 1L))
{
if (poly1[j] != 0L)
{
fmpz_set(h[i], poly1 + j);
hlen[i] = 1;
}
}
_fmpz_poly_mul(pow, poly2, len2, poly2, len2);
powlen = 2 * len2 - 1;
for (n = (len1 + 1) / 2; n > 2; n = (n + 1) / 2)
{
if (hlen[1] > 0)
{
long templen = powlen + hlen[1] - 1;
_fmpz_poly_mul(temp, pow, powlen, h[1], hlen[1]);
_fmpz_poly_add(h[0], temp, templen, h[0], hlen[0]);
hlen[0] = FLINT_MAX(hlen[0], templen);
}
for (i = 1; i < n / 2; i++)
{
if (hlen[2*i + 1] > 0)
{
_fmpz_poly_mul(h[i], pow, powlen, h[2*i + 1], hlen[2*i + 1]);
hlen[i] = hlen[2*i + 1] + powlen - 1;
} else
hlen[i] = 0;
_fmpz_poly_add(h[i], h[i], hlen[i], h[2*i], hlen[2*i]);
hlen[i] = FLINT_MAX(hlen[i], hlen[2*i]);
}
if ((n & 1L))
{
_fmpz_vec_set(h[i], h[2*i], hlen[2*i]);
hlen[i] = hlen[2*i];
}
_fmpz_poly_mul(temp, pow, powlen, pow, powlen);
powlen += powlen - 1;
{
fmpz * t = pow;
pow = temp;
temp = t;
}
}
_fmpz_poly_mul(res, pow, powlen, h[1], hlen[1]);
_fmpz_vec_add(res, res, h[0], hlen[0]);
_fmpz_vec_clear(v, alloc + 2 * powlen);
free(h);
free(hlen);
}
