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