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;
}
static __inline__ void
fmpz_poly_addlow(fmpz_poly_t c, const fmpz_poly_t a,
const fmpz_poly_t b, slong len)
{
fmpz_poly_add(c, a, b);
fmpz_poly_truncate(c, len);
}
int dgsl_rot_mp_call_plus_fmpz_poly(fmpz_poly_t rop, const dgsl_rot_mp_t *self, const fmpz_poly_t c, gmp_randstate_t state) {
fmpz_poly_t t; fmpz_poly_init(t);
fmpz_poly_set(t, c);
fmpq_poly_t tq; fmpq_poly_init(tq); // == 0
fmpq_poly_set_fmpz_poly(tq, t);
fmpq_poly_neg(tq, tq);
dgsl_rot_mp_call_recenter_fmpq_poly(rop, self, tq, state);
fmpz_poly_add(rop, rop, t);
fmpq_poly_clear(tq);
fmpz_poly_clear(t);
return 0;
}
void
fmpz_poly_mat_add(fmpz_poly_mat_t C,
const fmpz_poly_mat_t A, const fmpz_poly_mat_t B)
{
long i, j;
for (i = 0; i < A->r; i++)
for (j = 0; j < A->c; j++)
fmpz_poly_add(fmpz_poly_mat_entry(C, i, j),
fmpz_poly_mat_entry(A, i, j),
fmpz_poly_mat_entry(B, i, j));
}
void
fmpz_poly_mat_mullow(fmpz_poly_mat_t C, const fmpz_poly_mat_t A,
const fmpz_poly_mat_t B, long len)
{
long ar, bc, br;
long i, j, k;
fmpz_poly_t t;
ar = A->r;
br = B->r;
bc = B->c;
if (br == 0 || len < 1)
{
fmpz_poly_mat_zero(C);
return;
}
if (C == A || C == B)
{
fmpz_poly_mat_t T;
fmpz_poly_mat_init(T, ar, bc);
fmpz_poly_mat_mullow(T, A, B, len);
fmpz_poly_mat_swap(C, T);
fmpz_poly_mat_clear(T);
return;
}
fmpz_poly_init(t);
for (i = 0; i < ar; i++)
{
for (j = 0; j < bc; j++)
{
fmpz_poly_mullow(fmpz_poly_mat_entry(C, i, j),
fmpz_poly_mat_entry(A, i, 0),
fmpz_poly_mat_entry(B, 0, j), len);
for (k = 1; k < br; k++)
{
fmpz_poly_mullow(t, fmpz_poly_mat_entry(A, i, k),
fmpz_poly_mat_entry(B, k, j), len);
fmpz_poly_add(fmpz_poly_mat_entry(C, i, j),
fmpz_poly_mat_entry(C, i, j), 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));
}
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_addmul_fmpz....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_t x;
fmpz_init(x);
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_randtest(x, state, n_randint(state, 100));
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_set(b, a);
fmpz_poly_set(c, a);
fmpz_poly_scalar_addmul_fmpz(b, a, x);
fmpz_poly_scalar_addmul_fmpz(a, a, x);
result = (fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL (1):\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
flint_printf("x = "), fmpz_print(x), flint_printf("\n\n");
abort();
}
fmpz_clear(x);
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check that b += x*a is the same as c = b + x*a */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_t x;
fmpz_init(x);
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_randtest(x, state, n_randint(state, 100));
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_randtest(b, state, n_randint(state, 100), 200);
fmpz_poly_scalar_mul_fmpz(c, a, x);
fmpz_poly_add(c, b, c);
fmpz_poly_scalar_addmul_fmpz(b, a, x);
result = (fmpz_poly_equal(b, c));
if (!result)
{
flint_printf("FAIL (2):\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
flint_printf("x = "), fmpz_print(x), flint_printf("\n\n");
abort();
}
fmpz_clear(x);
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("mul....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 500);
fmpz_poly_randtest(c, state, n_randint(state, 50), 500);
fmpz_poly_mul(a, b, c);
fmpz_poly_mul(b, b, c);
result = (fmpz_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(b), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check aliasing of a and c */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(b, state, n_randint(state, 50), 500);
fmpz_poly_randtest(c, state, n_randint(state, 50), 500);
fmpz_poly_mul(a, b, c);
fmpz_poly_mul(c, b, c);
result = (fmpz_poly_equal(a, c));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(c), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check (b*c)+(b*d) = b*(c+d) */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a1, a2, b, c, d;
fmpz_poly_init(a1);
fmpz_poly_init(a2);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_init(d);
fmpz_poly_randtest(b, state, n_randint(state, 100), 500);
fmpz_poly_randtest(c, state, n_randint(state, 100), 500);
fmpz_poly_randtest(d, state, n_randint(state, 100), 500);
fmpz_poly_mul(a1, b, c);
fmpz_poly_mul(a2, b, d);
fmpz_poly_add(a1, a1, a2);
fmpz_poly_add(c, c, d);
fmpz_poly_mul(a2, b, c);
result = (fmpz_poly_equal(a1, a2));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a1), printf("\n\n");
fmpz_poly_print(a2), printf("\n\n");
abort();
}
fmpz_poly_clear(a1);
fmpz_poly_clear(a2);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(d);
}
/* Check _fmpz_poly_mul directly */
for (i = 0; i < 2000; i++)
{
long len1, len2;
fmpz_poly_t a, b, out1, out2;
len1 = n_randint(state, 100) + 1;
len2 = n_randint(state, 100) + 1;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(out1);
fmpz_poly_init(out2);
fmpz_poly_randtest(a, state, len1, 200);
fmpz_poly_randtest(b, state, len2, 200);
fmpz_poly_mul(out1, a, b);
fmpz_poly_fit_length(a, a->alloc + n_randint(state, 10));
fmpz_poly_fit_length(b, b->alloc + n_randint(state, 10));
a->length = a->alloc;
b->length = b->alloc;
fmpz_poly_fit_length(out2, a->length + b->length - 1);
if (a->length >= b->length)
_fmpz_poly_mul(out2->coeffs, a->coeffs, a->length,
b->coeffs, b->length);
else
_fmpz_poly_mul(out2->coeffs, b->coeffs, b->length,
a->coeffs, a->length);
_fmpz_poly_set_length(out2, a->length + b->length - 1);
_fmpz_poly_normalise(out2);
result = (fmpz_poly_equal(out1, out2));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(out1), printf("\n\n");
fmpz_poly_print(out2), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(out1);
fmpz_poly_clear(out2);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("divrem_basecase....");
fflush(stdout);
flint_randinit(state);
/* Check q*b + r = a, no aliasing */
for (i = 0; i < 2000; i++)
{
fmpz_poly_t a, b, q, r, prod;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_init(prod);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_mul(prod, q, b);
fmpz_poly_add(prod, prod, r);
result = (fmpz_poly_equal(a, prod));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(prod), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
fmpz_poly_clear(prod);
}
/* Check r and a alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(q, a, a, b);
result = (fmpz_poly_equal(a, r));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
/* Check r and b alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(q, b, a, b);
result = (fmpz_poly_equal(b, r));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
/* Check q and a alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(a, r, a, b);
result = (fmpz_poly_equal(a, q));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
/* Check q and b alias */
for (i = 0; i < 1000; i++)
{
fmpz_poly_t a, b, q, r;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(q);
fmpz_poly_init(r);
fmpz_poly_randtest(a, state, n_randint(state, 100), 100);
fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 100);
fmpz_poly_divrem_basecase(q, r, a, b);
fmpz_poly_divrem_basecase(b, r, a, b);
result = (fmpz_poly_equal(b, q));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(a), printf("\n\n");
fmpz_poly_print(q), printf("\n\n");
fmpz_poly_print(r), printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(q);
fmpz_poly_clear(r);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
bool
poly_inverse_poly_q(fmpz_poly_t Fq,
const fmpz_poly_t a,
const ntru_params *params)
{
bool retval = false;
int k = 0,
j = 0;
fmpz *b_last;
fmpz_poly_t a_tmp,
b,
c,
f,
g;
/* general initialization of temp variables */
fmpz_poly_init(b);
fmpz_poly_set_coeff_ui(b, 0, 1);
fmpz_poly_init(c);
fmpz_poly_init(f);
fmpz_poly_set(f, a);
/* set g(x) = x^N − 1 */
fmpz_poly_init(g);
fmpz_poly_set_coeff_si(g, 0, -1);
fmpz_poly_set_coeff_si(g, params->N, 1);
/* avoid side effects */
fmpz_poly_init(a_tmp);
fmpz_poly_set(a_tmp, a);
fmpz_poly_zero(Fq);
while (1) {
while (fmpz_poly_get_coeff_ptr(f, 0) &&
fmpz_is_zero(fmpz_poly_get_coeff_ptr(f, 0))) {
for (uint32_t i = 1; i <= params->N; i++) {
fmpz *f_coeff = fmpz_poly_get_coeff_ptr(f, i);
fmpz *c_coeff = fmpz_poly_get_coeff_ptr(c, params->N - i);
/* f(x) = f(x) / x */
fmpz_poly_set_coeff_fmpz_n(f, i - 1,
f_coeff);
/* c(x) = c(x) * x */
fmpz_poly_set_coeff_fmpz_n(c, params->N + 1 - i,
c_coeff);
}
fmpz_poly_set_coeff_si(f, params->N, 0);
fmpz_poly_set_coeff_si(c, 0, 0);
k++;
if (fmpz_poly_degree(f) == -1)
goto cleanup;
}
if (fmpz_poly_is_zero(g) == 1)
goto cleanup;
if (fmpz_poly_degree(f) == 0)
break;
if (fmpz_poly_degree(f) < fmpz_poly_degree(g)) {
fmpz_poly_swap(f, g);
fmpz_poly_swap(b, c);
}
fmpz_poly_add(f, g, f);
fmpz_poly_mod_unsigned(f, 2);
fmpz_poly_add(b, c, b);
fmpz_poly_mod_unsigned(b, 2);
}
k = k % params->N;
b_last = fmpz_poly_get_coeff_ptr(b, params->N);
if (fmpz_cmp_si_n(b_last, 0))
goto cleanup;
/* Fq(x) = x^(N-k) * b(x) */
for (int i = params->N - 1; i >= 0; i--) {
fmpz *b_i;
j = i - k;
if (j < 0)
j = j + params->N;
b_i = fmpz_poly_get_coeff_ptr(b, i);
fmpz_poly_set_coeff_fmpz_n(Fq, j, b_i);
}
poly_mod2_to_modq(Fq, a_tmp, params);
/* check if the f * Fq = 1 (mod p) condition holds true */
fmpz_poly_set(a_tmp, a);
poly_starmultiply(a_tmp, a_tmp, Fq, params, params->q);
if (fmpz_poly_is_one(a_tmp))
retval = true;
else
fmpz_poly_zero(Fq);
cleanup:
fmpz_poly_clear(a_tmp);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
return retval;
}
var AddPolyZ(const Tuple& x,const Tuple& y){
fmpz_poly_t res;
fmpz_poly_init(res);
fmpz_poly_add(res,to_fmpz_poly(x),to_fmpz_poly(y));
return from_fmpz_poly(res);
}
