int
main(void)
{
int i, result;
flint_rand_t state;
printf("init_set....");
fflush(stdout);
flint_randinit(state);
/* Small integers */
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
fmpz_init(a);
fmpz_randtest(a, state, FLINT_BITS - 2);
fmpz_init_set(b, a);
result = fmpz_equal(a, b);
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), fmpz_print(a), printf("\n");
printf("b = "), fmpz_print(b), printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
/* Large integers */
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
fmpz_init(a);
fmpz_randtest(a, state, 2 * FLINT_BITS);
fmpz_init_set(b, a);
result = fmpz_equal(a, b);
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), fmpz_print(a), printf("\n");
printf("b = "), fmpz_print(b), printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
static __inline__ void
fmpz_vec_init_set(fmpz* vec1, const fmpz* vec2, slong len2)
// ignore contents of vec1, perform deep copy
{
for ( ; len2--; )
fmpz_init_set(vec1 + len2, vec2 + len2);
}
static __inline__ void
fmpz_mat_window_unsh_mul_general_triu( MUL_TYPE_ARG )
// R := A*B where B is upper-triangular square
{
slong d0=R->r, d1=B->c, i,j,k;
fmpz* p,* q,* rho;
fmpz** r=R->rows;
fmpz** b=B->rows;
fmpz** a=A->rows;
slong B_delta=B->delta;
fmpz_t B_00; fmpz_init_set( B_00, b[0] );
for( i=0; i<d0; i++ )
{
rho=r[i];
p=a[i];
fmpz_mul( rho, p, B_00 );
rho++;
for( j=1; j<d1; j++ )
{
fmpz_clear_and_zero( rho );
q=b[0]+j;
// multiply j entries
for( k=0; k<j; k++,q += B_delta )
fmpz_addmul( rho, p+k, q );
// multiply j'th entry
fmpz_addmul( rho, p+j, q );
rho++;
}
}
fmpz_clear( B_00 );
}
void _fmpz_mod_poly_radix_init(fmpz **Rpow, fmpz **Rinv,
const fmpz *R, long lenR, long k,
const fmpz_t invL, const fmpz_t p)
{
const long degR = lenR - 1;
long i;
fmpz_t invLP;
fmpz *W;
fmpz_init_set(invLP, invL);
W = flint_malloc((1L << (k - 1)) * degR * sizeof(fmpz));
_fmpz_vec_set(Rpow[0], R, lenR);
for (i = 1; i < k; i++)
{
_fmpz_mod_poly_sqr(Rpow[i], Rpow[i - 1], degR * (1L << (i - 1)) + 1, p);
}
for (i = 0; i < k; i++)
{
const long lenQ = (1L << i) * degR;
long j;
/* W := rev{Rpow[i], lenQ} */
for (j = 0; j < lenQ; j++)
{
W[j] = Rpow[i][lenQ - j];
}
_fmpz_mod_poly_inv_series_newton(Rinv[i], W, lenQ, invLP, p);
/* invLP := inv{lead{R^{2^i}}} */
if (i != k - 1)
{
fmpz_mul(invLP, invLP, invLP);
fmpz_mod(invLP, invLP, p);
}
}
fmpz_clear(invLP);
flint_free(W);
}
static void
add_work(obf_state_t *s, fmpz_mat_t *mats, mmap_enc_mat_t **enc_mats,
int **pows, long c, long i, long j, char *tag)
{
fmpz_t *plaintext;
mmap_enc *enc;
struct encode_elem_s *args;
plaintext = malloc(sizeof(fmpz_t));
args = malloc(sizeof(struct encode_elem_s));
fmpz_init_set(*plaintext, fmpz_mat_entry(mats[c], i, j));
enc = enc_mats[c][0]->m[i][j];
args->group = pows[c];
args->n = 1;
args->plaintext = plaintext;
args->vtable = s->vtable;
args->sk = s->mmap;
args->enc = enc;
args->rand = &s->rand;
thpool_add_work(s->thpool, thpool_encode_elem, (void *) args, tag);
}
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);
}
static __inline__ void
fmpz_mat_window_unsh_mul_negate_triu_general( MUL_TYPE_ARG )
// R := -A*B where A is upper-triangular square
{
slong d0=R->r, d1=B->c, i,j,k;
slong d0_minus=d0-1;
fmpz* p,* q,* rho;
fmpz** r=R->rows;
fmpz** b=B->rows;
fmpz** a=A->rows;
slong B_delta=B->delta;
fmpz_t scr;
// All rows but last
for (i=0; i<d0_minus; i++)
{
rho=r[i];
p=a[i]; // to skip i zeroes at start of a, add i
for ( j=0; j<d1; j++ )
{
q=b[i]+j; // skip i rows of b, then go to j'th column
fmpz_clear_and_zero( rho );
for( k=i; k<d0; k++, q += B_delta )
fmpz_addmul( rho, p+k, q );
fmpz_neg_1arg( rho );
rho++;
}
}
// last row: scalar multiply
p=r[d0_minus]; q=b[d0_minus];
fmpz_init_set( scr, a[d0_minus]+d0_minus ); fmpz_neg_1arg( scr );
for( i=d1; i--; )
{
fmpz_mul( p, q, scr );
p++;
q++;
}
fmpz_clear( scr );
}
void*
integer_copy(void* v){
fmpz* res=new fmpz;
fmpz_init_set(res,(fmpz*)v);
return res;
}
bool
poly_inverse_poly_p(fmpz_poly_t Fp,
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(Fp);
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)) {
/* exchange f and g and exchange b and c */
fmpz_poly_swap(f, g);
fmpz_poly_swap(b, c);
}
{
fmpz_poly_t c_tmp,
g_tmp;
fmpz_t u,
mp_tmp;
fmpz_init(u);
fmpz_zero(u);
fmpz_init_set(mp_tmp, fmpz_poly_get_coeff_ptr(f, 0));
fmpz_poly_init(g_tmp);
fmpz_poly_set(g_tmp, g);
fmpz_poly_init(c_tmp);
fmpz_poly_set(c_tmp, c);
/* u = f[0] * g[0]^(-1) mod p */
/* = (f[0] mod p) * (g[0] inverse mod p) mod p */
fmpz_invmod_ui(u,
fmpz_poly_get_coeff_ptr(g, 0),
params->p);
fmpz_mod_ui(mp_tmp, mp_tmp, params->p);
fmpz_mul(u, mp_tmp, u);
fmpz_mod_ui(u, u, params->p);
/* f = f - u * g mod p */
fmpz_poly_scalar_mul_fmpz(g_tmp, g_tmp, u);
fmpz_poly_sub(f, f, g_tmp);
fmpz_poly_mod_unsigned(f, params->p);
/* b = b - u * c mod p */
fmpz_poly_scalar_mul_fmpz(c_tmp, c_tmp, u);
fmpz_poly_sub(b, b, c_tmp);
fmpz_poly_mod_unsigned(b, params->p);
fmpz_clear(u);
fmpz_poly_clear(g_tmp);
fmpz_poly_clear(c_tmp);
}
}
k = k % params->N;
b_last = fmpz_poly_get_coeff_ptr(b, params->N);
if (fmpz_cmp_si_n(b_last, 0))
goto cleanup;
/* Fp(x) = x^(N-k) * b(x) */
for (int i = params->N - 1; i >= 0; i--) {
fmpz *b_i;
/* b(X) = f[0]^(-1) * b(X) (mod p) */
{
fmpz_t mp_tmp;
fmpz_init(mp_tmp);
fmpz_invmod_ui(mp_tmp,
fmpz_poly_get_coeff_ptr(f, 0),
params->p);
if (fmpz_poly_get_coeff_ptr(b, i)) {
fmpz_mul(fmpz_poly_get_coeff_ptr(b, i),
fmpz_poly_get_coeff_ptr(b, i),
mp_tmp);
fmpz_mod_ui(fmpz_poly_get_coeff_ptr(b, i),
fmpz_poly_get_coeff_ptr(b, i),
params->p);
}
}
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(Fp, j, b_i);
}
/* check if the f * Fp = 1 (mod p) condition holds true */
fmpz_poly_set(a_tmp, a);
poly_starmultiply(a_tmp, a_tmp, Fp, params, params->p);
if (fmpz_poly_is_one(a_tmp))
retval = true;
else
fmpz_poly_zero(Fp);
cleanup:
fmpz_poly_clear(a_tmp);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
return retval;
}
