void fmpz_poly_sqrlow(fmpz_poly_t res, const fmpz_poly_t poly, long n) { const long len = poly->length; if (len == 0 || n == 0) { fmpz_poly_zero(res); return; } if (res == poly) { fmpz_poly_t t; fmpz_poly_init2(t, n); fmpz_poly_sqrlow(t, poly, n); fmpz_poly_swap(res, t); fmpz_poly_clear(t); return; } n = FLINT_MIN(2 * len - 1, n); fmpz_poly_fit_length(res, n); _fmpz_poly_sqrlow(res->coeffs, poly->coeffs, len, n); _fmpz_poly_set_length(res, n); _fmpz_poly_normalise(res); }
void fmpz_poly_disc_gauss_rounding(fmpz_poly_t rop, const fmpq_poly_t x, const mpfr_t r_f, gmp_randstate_t randstate) { mpfr_t xi; mpfr_init2(xi, mpfr_get_prec(r_f)); mpf_t xi_f; mpf_init2(xi_f, mpfr_get_prec(r_f)); mpq_t xi_q; mpq_init(xi_q); mpz_t s_z; mpz_init(s_z); const long n = fmpq_poly_length(x); const size_t tau = (ceil(2*sqrt(log2((double)n))) > 3) ? ceil(2*sqrt(log2((double)n))) : 3; fmpz_poly_zero(rop); for(int i=0; i<n; i++) { fmpq_poly_get_coeff_mpq(xi_q, x, i); mpf_set_q(xi_f, xi_q); mpfr_set_f(xi, xi_f, MPFR_RNDN); dgs_disc_gauss_mp_t *D = dgs_disc_gauss_mp_init(r_f, xi, tau, DGS_DISC_GAUSS_UNIFORM_ONLINE); D->call(s_z, D, randstate); dgs_disc_gauss_mp_clear(D); fmpz_poly_set_coeff_mpz(rop, i, s_z); } mpz_clear(s_z); mpq_clear(xi_q); mpf_clear(xi_f); mpfr_clear(xi); }
void fmpz_poly_mulhigh_classical(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, long start) { long len_out = poly1->length + poly2->length - 1; if (poly1->length == 0 || poly2->length == 0 || start >= len_out) { fmpz_poly_zero(res); return; } if (res == poly1 || res == poly2) { fmpz_poly_t temp; fmpz_poly_init2(temp, len_out); _fmpz_poly_mulhigh_classical(temp->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, start); fmpz_poly_swap(res, temp); fmpz_poly_clear(temp); } else { fmpz_poly_fit_length(res, len_out); _fmpz_poly_mulhigh_classical(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, start); } _fmpz_poly_set_length(res, len_out); }
void fmpz_poly_mullow_classical(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, long n) { long len_out; if (poly1->length == 0 || poly2->length == 0 || n == 0) { fmpz_poly_zero(res); return; } len_out = poly1->length + poly2->length - 1; if (n > len_out) n = len_out; if (res == poly1 || res == poly2) { fmpz_poly_t t; fmpz_poly_init2(t, n); _fmpz_poly_mullow_classical(t->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, n); fmpz_poly_swap(res, t); fmpz_poly_clear(t); } else { fmpz_poly_fit_length(res, n); _fmpz_poly_mullow_classical(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, n); } _fmpz_poly_set_length(res, n); _fmpz_poly_normalise(res); }
void fmpz_poly_bit_unpack_unsigned(fmpz_poly_t poly, const fmpz_t f, mp_bitcnt_t bit_size) { slong len; mpz_t tmp; if (fmpz_sgn(f) < 0) { flint_printf("Exception (fmpz_poly_bit_unpack_unsigned). Expected an unsigned value.\n"); abort(); } if (bit_size == 0 || fmpz_is_zero(f)) { fmpz_poly_zero(poly); return; } len = (fmpz_bits(f) + bit_size - 1) / bit_size; mpz_init2(tmp, bit_size*len); flint_mpn_zero(tmp->_mp_d, tmp->_mp_alloc); fmpz_get_mpz(tmp, f); fmpz_poly_fit_length(poly, len); _fmpz_poly_bit_unpack_unsigned(poly->coeffs, len, tmp->_mp_d, bit_size); _fmpz_poly_set_length(poly, len); _fmpz_poly_normalise(poly); mpz_clear(tmp); }
void fmpz_poly_mulmid_classical(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) { slong len_out; if (poly1->length == 0 || poly2->length == 0) { fmpz_poly_zero(res); return; } len_out = poly1->length - poly2->length + 1; if (res == poly1 || res == poly2) { fmpz_poly_t temp; fmpz_poly_init2(temp, len_out); _fmpz_poly_mulmid_classical(temp->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length); fmpz_poly_swap(res, temp); fmpz_poly_clear(temp); } else { fmpz_poly_fit_length(res, len_out); _fmpz_poly_mulmid_classical(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length); } _fmpz_poly_set_length(res, len_out); _fmpz_poly_normalise(res); }
void fmpz_poly_scalar_mul_ui(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) { long i; /* Either scalar or input poly is zero */ if ((x == 0) || (poly2->length == 0)) { fmpz_poly_zero(poly1); return; } /* Special case, multiply by 1 */ if (x == 1) { fmpz_poly_set(poly1, poly2); return; } fmpz_poly_fit_length(poly1, poly2->length); for (i = 0; i < poly2->length; i++) fmpz_mul_ui(poly1->coeffs + i, poly2->coeffs + i, x); _fmpz_poly_set_length(poly1, poly2->length); }
void fmpz_poly_mullow_KS(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, long n) { const long len1 = poly1->length; const long len2 = poly2->length; if (len1 == 0 || len2 == 0 || n == 0) { fmpz_poly_zero(res); return; } if (res == poly1 || res == poly2) { fmpz_poly_t t; fmpz_poly_init2(t, n); fmpz_poly_mullow_KS(t, poly1, poly2, n); fmpz_poly_swap(res, t); fmpz_poly_clear(t); return; } fmpz_poly_fit_length(res, n); if (len1 >= len2) _fmpz_poly_mullow_KS(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, n); else _fmpz_poly_mullow_KS(res->coeffs, poly2->coeffs, len2, poly1->coeffs, len1, n); _fmpz_poly_set_length(res, n); _fmpz_poly_normalise(res); }
void fmpz_poly_sqr_classical(fmpz_poly_t rop, const fmpz_poly_t op) { long len; if (op->length == 0) { fmpz_poly_zero(rop); return; } len = 2 * op->length - 1; if (rop == op) { fmpz_poly_t t; fmpz_poly_init2(t, len); _fmpz_poly_sqr_classical(t->coeffs, op->coeffs, op->length); fmpz_poly_swap(rop, t); fmpz_poly_clear(t); } else { fmpz_poly_fit_length(rop, len); _fmpz_poly_sqr_classical(rop->coeffs, op->coeffs, op->length); } _fmpz_poly_set_length(rop, len); }
int fmpz_poly_sqrt_classical(fmpz_poly_t b, const fmpz_poly_t a) { long blen, len = a->length; int result; if (len % 2 == 0) { fmpz_poly_zero(b); return len == 0; } if (b == a) { fmpz_poly_t tmp; fmpz_poly_init(tmp); result = fmpz_poly_sqrt(tmp, a); fmpz_poly_swap(b, tmp); fmpz_poly_clear(tmp); return result; } blen = len / 2 + 1; fmpz_poly_fit_length(b, blen); _fmpz_poly_set_length(b, blen); result = _fmpz_poly_sqrt_classical(b->coeffs, a->coeffs, len); if (!result) _fmpz_poly_set_length(b, 0); return result; }
int dgsl_rot_mp_call_gpv_inlattice(fmpz_poly_t rop, const dgsl_rot_mp_t *self, gmp_randstate_t state) { assert(rop); assert(self); const long n = self->n; mpz_t tmp_z; mpz_init(tmp_z); fmpz_t tmp; fmpz_init(tmp); fmpz_poly_zero(rop); fmpz_poly_t tmp_poly; fmpz_poly_init(tmp_poly); fmpz_poly_set(tmp_poly, self->B); fmpz_poly_realloc(tmp_poly, n); tmp_poly->length = n; fmpz_poly_t tmp2; fmpz_poly_init(tmp2); for(long i=0; i<n; i++) { self->D[i]->call(tmp_z, self->D[i], state); fmpz_set_mpz(tmp, tmp_z); fmpz_poly_scalar_mul_fmpz(tmp2, tmp_poly, tmp); fmpz_poly_add(rop, rop, tmp2); _fmpz_vec_rot_left_neg(tmp_poly->coeffs, tmp_poly->coeffs, n); } fmpz_poly_clear(tmp_poly); fmpz_poly_add(rop, rop, self->c_z); fmpz_poly_clear(tmp2); mpz_clear(tmp_z); fmpz_clear(tmp); return 0; }
int padic_poly_get_fmpz_poly(fmpz_poly_t rop, const padic_poly_t op, const padic_ctx_t ctx) { const slong len = op->length; if (op->val < 0) { return 0; } if (padic_poly_is_zero(op)) { fmpz_poly_zero(rop); return 1; } fmpz_poly_fit_length(rop, len); _fmpz_poly_set_length(rop, len); if (op->val == 0) { _fmpz_vec_set(rop->coeffs, op->coeffs, len); } else /* op->val > 0 */ { fmpz_t pow; fmpz_init(pow); fmpz_pow_ui(pow, ctx->p, op->val); _fmpz_vec_scalar_mul_fmpz(rop->coeffs, op->coeffs, len, pow); fmpz_clear(pow); } return 1; }
static void poly_mod2_to_modq(fmpz_poly_t Fq, const fmpz_poly_t a, const ntru_params *params) { int v = 2; fmpz_poly_t poly_tmp, two; fmpz_poly_init(poly_tmp); fmpz_poly_zero(poly_tmp); fmpz_poly_init(two); fmpz_poly_set_coeff_ui(two, 0, 2); while (v < (int)(params->q)) { v = v * 2; poly_starmultiply(poly_tmp, a, Fq, params, v); fmpz_poly_sub(poly_tmp, two, poly_tmp); fmpz_poly_mod_unsigned(poly_tmp, v); poly_starmultiply(Fq, Fq, poly_tmp, params, v); } fmpz_poly_clear(poly_tmp); fmpz_poly_clear(two); }
void fmpz_poly_mul_karatsuba(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) { long len_out; if ((poly1->length == 0) || (poly2->length == 0)) { fmpz_poly_zero(res); return; } len_out = poly1->length + poly2->length - 1; fmpz_poly_fit_length(res, len_out); if (poly1->length >= poly2->length) _fmpz_poly_mul_karatsuba(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length); else _fmpz_poly_mul_karatsuba(res->coeffs, poly2->coeffs, poly2->length, poly1->coeffs, poly1->length); _fmpz_poly_set_length(res, len_out); }
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_poly_set_ui(fmpz_poly_t poly, ulong c) { if (c == UWORD(0)) fmpz_poly_zero(poly); else { fmpz_poly_fit_length(poly, 1); fmpz_set_ui(poly->coeffs, c); _fmpz_poly_set_length(poly, 1); } }
/* Applies the operator $\sigma^e$ to all elements in the matrix \code{op}, setting the corresponding elements in \code{rop} to the results. */ static void fmpz_poly_mat_frobenius(fmpz_poly_mat_t B, const fmpz_poly_mat_t A, long e, const fmpz_t p, long N, const qadic_ctx_t ctx) { const long d = qadic_ctx_degree(ctx); e = e % d; if (e < 0) e += d; if (e == 0) { fmpz_t pN; fmpz_init(pN); fmpz_pow_ui(pN, p, N); fmpz_poly_mat_scalar_mod_fmpz(B, A, pN); fmpz_clear(pN); } else { long i, j; fmpz *t = _fmpz_vec_init(2 * d - 1); for (i = 0; i < B->r; i++) for (j = 0; j < B->c; j++) { const fmpz_poly_struct *a = fmpz_poly_mat_entry(A, i, j); fmpz_poly_struct *b = fmpz_poly_mat_entry(B, i, j); if (a->length == 0) { fmpz_poly_zero(b); } else { _qadic_frobenius(t, a->coeffs, a->length, e, ctx->a, ctx->j, ctx->len, p, N); fmpz_poly_fit_length(b, d); _fmpz_vec_set(b->coeffs, t, d); _fmpz_poly_set_length(b, d); _fmpz_poly_normalise(b); } } _fmpz_vec_clear(t, 2 * d - 1); } }
void fmpz_poly_compose_series(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, long n) { long len1 = poly1->length; long len2 = poly2->length; long lenr; if (len2 != 0 && !fmpz_is_zero(poly2->coeffs)) { printf("exception: fmpz_poly_compose_series: inner polynomial " "must have zero constant term\n"); abort(); } if (len1 == 0 || n == 0) { fmpz_poly_zero(res); return; } if (len2 == 0 || len1 == 1) { fmpz_poly_set_fmpz(res, poly1->coeffs); return; } lenr = FLINT_MIN((len1 - 1) * (len2 - 1) + 1, n); len1 = FLINT_MIN(len1, lenr); len2 = FLINT_MIN(len2, lenr); if ((res != poly1) && (res != poly2)) { fmpz_poly_fit_length(res, lenr); _fmpz_poly_compose_series(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, lenr); _fmpz_poly_set_length(res, lenr); _fmpz_poly_normalise(res); } else { fmpz_poly_t t; fmpz_poly_init2(t, lenr); _fmpz_poly_compose_series(t->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, lenr); _fmpz_poly_set_length(t, lenr); _fmpz_poly_normalise(t); fmpz_poly_swap(res, t); fmpz_poly_clear(t); } }
void fmpz_poly_mat_trace(fmpz_poly_t trace, const fmpz_poly_mat_t mat) { long i, n = fmpz_poly_mat_nrows(mat); if (n == 0) fmpz_poly_zero(trace); else { fmpz_poly_set(trace, fmpz_poly_mat_entry(mat, 0, 0)); for (i = 1; i < n; i++) fmpz_poly_add(trace, trace, fmpz_poly_mat_entry(mat, i, i)); } }
void fmpz_poly_scalar_mul_2exp(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong exp) { if (poly2->length == 0) { fmpz_poly_zero(poly1); return; } fmpz_poly_fit_length(poly1, poly2->length); _fmpz_vec_scalar_mul_2exp(poly1->coeffs, poly2->coeffs, poly2->length, exp); _fmpz_poly_set_length(poly1, poly2->length); }
void fmpz_poly_scalar_mul_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) { /* Either scalar or input poly is zero */ if ((*x == 0) || (poly2->length == 0)) { fmpz_poly_zero(poly1); return; } fmpz_poly_fit_length(poly1, poly2->length); _fmpz_vec_scalar_mul_fmpz(poly1->coeffs, poly2->coeffs, poly2->length, x); _fmpz_poly_set_length(poly1, poly2->length); }
static void fmpz_poly_compose_pow(fmpz_poly_t rop, const fmpz_poly_t op, long k) { const long len = op->length; const long lenr = (len - 1) * k + 1; if (len == 0) { fmpz_poly_zero(rop); } else { fmpz_poly_fit_length(rop, lenr); _fmpz_poly_compose_pow(rop->coeffs, op->coeffs, len, k); _fmpz_poly_set_length(rop, lenr); } }
void fmpz_poly_pow_multinomial(fmpz_poly_t res, const fmpz_poly_t poly, ulong e) { const long len = poly->length; long rlen; if ((len < 2) | (e < 3UL)) { if (e == 0UL) fmpz_poly_set_ui(res, 1); else if (len == 0) fmpz_poly_zero(res); else if (len == 1) { fmpz_poly_fit_length(res, 1); fmpz_pow_ui(res->coeffs, poly->coeffs, e); _fmpz_poly_set_length(res, 1); } else if (e == 1UL) fmpz_poly_set(res, poly); else /* e == 2UL */ fmpz_poly_sqr(res, poly); return; } rlen = (long) e * (len - 1) + 1; if (res != poly) { fmpz_poly_fit_length(res, rlen); _fmpz_poly_pow_multinomial(res->coeffs, poly->coeffs, len, e); _fmpz_poly_set_length(res, rlen); } else { fmpz_poly_t t; fmpz_poly_init2(t, rlen); _fmpz_poly_pow_multinomial(t->coeffs, poly->coeffs, len, e); _fmpz_poly_set_length(t, rlen); fmpz_poly_swap(res, t); fmpz_poly_clear(t); } }
int dgsl_rot_mp_call_identity(fmpz_poly_t rop, const dgsl_rot_mp_t *self, gmp_randstate_t state) { assert(rop); assert(self); const long n = self->n; mpz_t tmp_g; mpz_init(tmp_g); fmpz_poly_zero(rop); fmpz_poly_realloc(rop, n); for(long i=0; i<n; i++) { self->D[0]->call(tmp_g, self->D[0], state); fmpz_poly_set_coeff_mpz(rop, i, tmp_g); } _fmpz_poly_set_length(rop, n); _fmpz_poly_normalise(rop); mpz_clear(tmp_g); return 0; }
void fmpz_poly_scalar_divexact_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) { if (fmpz_is_zero(x)) { printf("Exception: division by zero in fmpz_poly_scalar_divexact_fmpz\n"); abort(); } if (poly2->length == 0) { fmpz_poly_zero(poly1); return; } fmpz_poly_fit_length(poly1, poly2->length); _fmpz_vec_scalar_divexact_fmpz(poly1->coeffs, poly2->coeffs, poly2->length, x); _fmpz_poly_set_length(poly1, poly2->length); }
void fmpz_poly_scalar_fdiv_ui(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) { if (x == 0) { flint_printf("Exception (fmpz_poly_scalar_fdiv_ui). Division by zero.\n"); abort(); } if (poly2->length == 0) { fmpz_poly_zero(poly1); return; } fmpz_poly_fit_length(poly1, poly2->length); _fmpz_vec_scalar_fdiv_q_ui(poly1->coeffs, poly2->coeffs, poly2->length, x); _fmpz_poly_set_length(poly1, poly2->length); }
void fmpz_poly_bit_unpack(fmpz_poly_t poly, const fmpz_t f, mp_bitcnt_t bit_size) { slong len; mpz_t tmp; int negate, borrow; if (bit_size == 0 || fmpz_is_zero(f)) { fmpz_poly_zero(poly); return; } /* Round up */ len = (fmpz_bits(f) + bit_size - 1) / bit_size; negate = (fmpz_sgn(f) < 0) ? -1 : 0; mpz_init2(tmp, bit_size*len); /* TODO: avoid all this wastefulness */ flint_mpn_zero(tmp->_mp_d, tmp->_mp_alloc); fmpz_get_mpz(tmp, f); fmpz_poly_fit_length(poly, len + 1); borrow = _fmpz_poly_bit_unpack(poly->coeffs, len, tmp->_mp_d, bit_size, negate); if (borrow) { fmpz_set_si(poly->coeffs + len, negate ? WORD(-1) : WORD(1)); _fmpz_poly_set_length(poly, len + 1); } else { _fmpz_poly_set_length(poly, len); _fmpz_poly_normalise(poly); } mpz_clear(tmp); }
void fmpz_poly_compose_divconquer(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) { const long len1 = poly1->length; const long len2 = poly2->length; long lenr; if (len1 == 0) { fmpz_poly_zero(res); return; } if (len1 == 1 || len2 == 0) { fmpz_poly_set_fmpz(res, poly1->coeffs); return; } lenr = (len1 - 1) * (len2 - 1) + 1; if (res != poly1 && res != poly2) { fmpz_poly_fit_length(res, lenr); _fmpz_poly_compose_divconquer(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2); _fmpz_poly_set_length(res, lenr); _fmpz_poly_normalise(res); } else { fmpz_poly_t t; fmpz_poly_init2(t, lenr); _fmpz_poly_compose_divconquer(t->coeffs, poly1->coeffs, len1, poly2->coeffs, len2); _fmpz_poly_set_length(t, lenr); _fmpz_poly_normalise(t); fmpz_poly_swap(res, t); fmpz_poly_clear(t); } }
void fmpz_poly_pseudo_div(fmpz_poly_t Q, ulong * d, const fmpz_poly_t A, const fmpz_poly_t B) { long lenq; fmpz * q; if (B->length == 0) { printf("Exception: division by zero in fmpz_poly_pseudo_div\n"); abort(); } if (A->length < B->length) { fmpz_poly_zero(Q); *d = 0; return; } lenq = A->length - B->length + 1; if (Q == A || Q == B) q = _fmpz_vec_init(lenq); else { fmpz_poly_fit_length(Q, lenq); q = Q->coeffs; } _fmpz_poly_pseudo_div(q, d, A->coeffs, A->length, B->coeffs, B->length); if (Q == A || Q == B) { _fmpz_vec_clear(Q->coeffs, Q->alloc); Q->coeffs = q; Q->alloc = lenq; Q->length = lenq; } else _fmpz_poly_set_length(Q, lenq); }
void fmpz_poly_mat_randtest_sparse(fmpz_poly_mat_t A, flint_rand_t state, long len, mp_bitcnt_t bits, float density) { long i, j; for (i = 0; i < A->r; i++) { for (j = 0; j < A->c; j++) { if (n_randint(state, 1000) < density * 1000) { long l = n_randint(state, len + 1); l = FLINT_MAX(l, 1); fmpz_poly_randtest_not_zero(fmpz_poly_mat_entry(A, i, j), state, l, bits); } else { fmpz_poly_zero(fmpz_poly_mat_entry(A, i, j)); } } } }