void
qcn_str (char *num)
{
mpz_t z;
mpz_init_set_str (z, num, 0);
if (mpz_sgn (z) >= 0)
{
mpz_out_str (stdout, 0, z);
printf (" is not supported (negatives only)\n");
}
else if (mpz_fdiv_ui (z, 4) != 0 && mpz_fdiv_ui (z, 4) != 1)
{
mpz_out_str (stdout, 0, z);
printf (" is not a discriminant (must == 0 or 1 mod 4)\n");
}
else
{
printf ("h(");
mpz_out_str (stdout, 0, z);
printf (") approx %.1f\n", qcn_estimate (z));
}
mpz_clear (z);
}
int rabin_miller(mpz_t n, unsigned int t, gmp_randstate_t rand_state) {
mpz_t a;
unsigned int res = PRIME, i;
/* skrati cas */
if (mpz_even_p(n)) return COMPOSITE;
if (mpz_fdiv_ui(n, 3) == 0) return COMPOSITE;
if (mpz_fdiv_ui(n, 5) == 0) return COMPOSITE;
if (mpz_fdiv_ui(n, 7) == 0) return COMPOSITE;
mpz_init(a);
for (i = 0; i < t; ++i) {
/* nahodne kladne a */
do {
mpz_urandomm(a,rand_state, n);
} while(mpz_sgn(a) == 0); /* nesmie byt 0 */
if(rabin_miller_test(n,a) == COMPOSITE) {
res = COMPOSITE;
break;
}
}
mpz_clear(a);
return res;
}
ulong
fmpz_fdiv_ui(const fmpz_t g, ulong h)
{
fmpz c1 = *g;
ulong r;
if (h == 0UL)
{
printf("Exception: division by 0 in fmpz_fdiv_ui\n");
abort();
}
if (!COEFF_IS_MPZ(c1)) /* g is small */
{
if (c1 < 0L)
{
r = h - (-c1 % h); /* C doesn't correctly handle negative mods */
if (r == h)
r = 0;
}
else
r = c1 % h;
return r;
}
else /* g is large */
{
return mpz_fdiv_ui(COEFF_TO_PTR(c1), h);
}
}
static int test_anr(UV a, mpz_t n, UV r, mpz_t* px, mpz_t* py)
{
int retval = 1;
UV i, n_mod_r;
mpz_t t;
for (i = 0; i < r; i++)
mpz_set_ui(px[i], 0);
mpz_set_ui(px[0], a);
mpz_set_ui(px[1], 1);
poly_mod_pow(py, px, n, r, n);
mpz_init(t);
n_mod_r = mpz_fdiv_ui(n, r);
mpz_sub_ui(t, py[n_mod_r], 1);
mpz_mod(py[n_mod_r], t, n);
mpz_sub_ui(t, py[0], a);
mpz_mod(py[0], t, n);
mpz_clear(t);
for (i = 0; i < r; i++)
if (mpz_sgn(py[i]))
retval = 0;
return retval;
}
static int VNRW_GMP_D1( const VNAsymCryptCtx_t * ctx, mpz_t zm )
{
int mod = 0;
VNRW_GMP_Ctx_t * gmpCtx = VN_CONTAINER_OF( ctx, VNRW_GMP_Ctx_t, mCtx );
assert( VN_TYPE_VNRWSign_GMP == ctx->mType || VN_TYPE_VNRWEnc_GMP == ctx->mType );
mod = mpz_fdiv_ui( zm, 4 );
if( 0 == mod )
{
mpz_cdiv_q_ui( zm, zm, 4 );
mpz_sub_ui( zm, zm, 1 );
} else if( 1 == mod ) {
mpz_sub( zm, gmpCtx->mN, zm );
mpz_cdiv_q_ui( zm, zm, 4 );
mpz_sub_ui( zm, zm, 1 );
} else if( 2 == mod ) {
mpz_cdiv_q_ui( zm, zm, 2 );
mpz_sub_ui( zm, zm, 1 );
} else if( 3 == mod ) {
mpz_sub( zm, gmpCtx->mN, zm );
mpz_cdiv_q_ui( zm, zm, 2 );
mpz_sub_ui( zm, zm, 1 );
}
mpz_cdiv_q_ui( zm, zm, 2 );
return 0;
}
/* modi */
static int modi(void *a, ltc_mp_digit b, ltc_mp_digit *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
*c = mpz_fdiv_ui(a, b);
return CRYPT_OK;
}
///@todo ensure that givaroField.cardinality() fits in a unsigned long, otherwise instead of mpz_fdiv_ui a different function has to be called)
void ARingGF::power_mpz(ElementType &result, const ElementType a, const mpz_ptr n) const
{
STT n1 = static_cast< STT>(mpz_fdiv_ui(n, givaroField.cardinality()-1));
//std::cerr << "exponent = " << n << std::endl;
//std::cerr << "n1 = " << n1 << std::endl;
power(result,a,n1);
}
void ARingGF::set_from_mpz(ElementType &result, const mpz_ptr a) const
{
//std::cerr << "set_from_mpz" << std::endl;
UTT b = static_cast< UTT>(mpz_fdiv_ui(a, mCharac));
// std::cerr << "b " << b << std::endl;
givaroField.init(result, b);
// std::cerr << "result " << result << std::endl;
}
/* modi */
static int modi(void *a, unsigned long b, unsigned long *c)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(c != NULL);
*c = mpz_fdiv_ui(a, b);
return CRYPT_OK;
}
int VNRW_GMP_GenKeys( VNAsymCryptCtx_t * ctx, int keyBits )
{
mpz_t zrand;
gmp_randstate_t state;
struct vn_iovec seed;
VNRW_GMP_Ctx_t * gmpCtx = VN_CONTAINER_OF( ctx, VNRW_GMP_Ctx_t, mCtx );
assert( VN_TYPE_VNRWSign_GMP == ctx->mType || VN_TYPE_VNRWEnc_GMP == ctx->mType );
keyBits = ( keyBits + 1 ) / 2;
mpz_init( zrand );
VNIovecGetRandomBuffer( &seed, ( keyBits / 8 + 1 ) );
mpz_import( zrand, seed.i.iov_len, 1, 1, 0, 0, seed.i.iov_base );
gmp_randinit_default( state );
gmp_randseed( state, zrand );
do {
mpz_urandomb( zrand, state, keyBits );
} while( keyBits != mpz_sizeinbase( zrand, 2 ) );
mpz_set( gmpCtx->mP, zrand );
do {
mpz_nextprime( gmpCtx->mP, gmpCtx->mP );
} while ( mpz_fdiv_ui( gmpCtx->mP, 8 ) != 3 );
mpz_set( gmpCtx->mQ, gmpCtx->mP );
do {
mpz_nextprime( gmpCtx->mQ, gmpCtx->mQ );
} while ( mpz_fdiv_ui( gmpCtx->mQ, 8 ) != 7 );
/* compute public key n */
mpz_mul( gmpCtx->mN, gmpCtx->mP, gmpCtx->mQ );
VNRW_CalcD( ctx );
gmp_randclear( state );
VNIovecFreeBufferAndTail( &seed );
mpz_clear( zrand );
return 0;
}
void
mpz_nextprime (mpz_ptr p, mpz_srcptr n)
{
mpz_t tmp;
unsigned short *moduli;
unsigned long difference;
int i;
int composite;
/* First handle tiny numbers */
if (mpz_cmp_ui (n, 2) < 0)
{
mpz_set_ui (p, 2);
return;
}
mpz_add_ui (p, n, 1);
mpz_setbit (p, 0);
if (mpz_cmp_ui (p, 7) <= 0)
return;
prime_limit = NUMBER_OF_PRIMES - 1;
if (mpz_cmp_ui (p, primes[prime_limit]) <= 0)
/* Just use first three entries (3,5,7) of table for small numbers */
prime_limit = 3;
if (prime_limit)
{
/* Compute residues modulo small odd primes */
moduli = (unsigned short *) TMP_ALLOC (prime_limit * sizeof moduli[0]);
for (i = 0; i < prime_limit; i++)
moduli[i] = mpz_fdiv_ui (p, primes[i]);
}
for (difference = 0; ; difference += 2)
{
composite = 0;
/* First check residues */
for (i = 0; i < prime_limit; i++)
{
int acc, pr;
composite |= (moduli[i] == 0);
acc = moduli[i] + 2;
pr = primes[i];
moduli[i] = acc >= pr ? acc - pr : acc;
}
if (composite)
continue;
mpz_add_ui (p, p, difference);
difference = 0;
/* Miller-Rabin test */
if (mpz_millerrabin (p, 2))
break;
}
}
void compute_coeffmod(unsigned int p, int deg, mpz_t *coeff)
{
int i;
if (assess_coeffmod_len<deg+1) {
assess_coeffmod_len=deg+1;
assess_coeffmod=(unsigned int *)xrealloc(assess_coeffmod,assess_coeffmod_len*sizeof(unsigned int));
}
for (i=0; i<=deg; i++) assess_coeffmod[i]=mpz_fdiv_ui(coeff[i],p);
}
/*------------------------------------------------------------------*/
static void poly_reduce_mod_p(poly_t res, mpzpoly_t _f, u_int32_t p)
{
u_int32_t i;
res->degree = _f->deg;
for (i = 0; i <= _f->deg; i++)
res->coef[i] = mpz_fdiv_ui(_f->c[i], p);
poly_fix_degree(res);
return;
}
static __inline__ mp_limb_t
invert_det_divisor_modulo_pk(mpz_t dd,p_k_pk_t const* pp,nmod_t const* mod)
// take dd modulo p_deg_k, then invert it
{
mp_limb_t r,m=pp->p_deg_k;
r=mpz_fdiv_ui(dd, m);
if(pp->k==1)
return n_invmod(r,m);
else
return inv_mod_pk_3arg(r,pp[0],mod[0]);
}
static __inline__ mp_limb_t
choose_prime_and_degree(p_k_pk_t* pp,nmod_t* mod,n_primes_rev_t it,
const mpz_t divisor)
{
mp_limb_t r,t=1,r_mod_p;
for(;;)
{
if( (pp->p = n_primes_rev_next(it)) == 1 )
{
flint_printf("Exception (choose_prime_and_degree): "
"Prime set exhausted\n");
abort();
}
if( pp->p >= (UWORD(1)<<(FLINT_BITS/2)) )
{
pp->k=1;
r=r_mod_p=mpz_fdiv_ui( divisor, pp->p_deg_k=pp->p );
t=0;
}
else
{
max_degree( pp );
r=mpz_fdiv_ui( divisor, pp->p_deg_k );
r_mod_p=r % pp->p;
}
if(r_mod_p)
{
if(t)
count_leading_zeros( t, pp->p_deg_k );
mod->n = pp->p_deg_k << t;
invert_limb(mod->ninv, mod->n);
#if SPEEDUP_NMOD_RED3
t = - mod->n;
mod->norm = n_mulmod_preinv_4arg( t,t, mod->n,mod->ninv );
#else
mod->norm = 0;
#endif
return inv_mod_pk_4arg(r,r_mod_p,pp[0],mod[0]);
}
}
}
void checkWilson (mpz_t f, unsigned long n)
{
unsigned long m;
mpz_fac_ui (f, n - 1);
m = mpz_fdiv_ui (f, n);
if ( m != n - 1)
{
printf ("mpz_fac_ui(%lu) wrong\n", n - 1);
printf (" Wilson's theorem not verified: got %lu, expected %lu.\n",m ,n - 1);
abort ();
}
}
vector<uint64> burns::set(mpz_t X) const
{
// int l = X->_mp_size;
// if (l < 0) l = -l;
// return set(X->_mp_d, l);
vector<uint64> xi;
xi.reserve(size());
for(int i=0; i < size(); i++)
{
const monty& m = mb.field(i);
uint64 residue = mpz_fdiv_ui(X, m.modulus());
xi.push_back(m.set(residue));
}
return xi;
}
double brute_force_proj(unsigned int p, int deg, mpz_t *gmp_coeff)
{
unsigned int qmax, h, q, q0;
unsigned int lifts[32], powers[32];
int ind, indmax, j;
double dp, lo, res;
qmax=1; indmax=0;
while (qmax<MAX_BF/p) { qmax*=p; powers[indmax++]=qmax; }
if (assess_mod_len<deg+1) {
assess_mod_len=deg+1;
assess_mod=(unsigned int *)xrealloc(assess_mod,assess_mod_len*sizeof(unsigned int));
}
for (j=0; j<=deg; j++) assess_mod[j]=mpz_fdiv_ui(gmp_coeff[deg-j],qmax);
dp=(double)p; lo=log(dp)*dp/(dp+1);
ind=0; lifts[0]=0; res=0.;
while (1) {
q=powers[ind]; res+=lo/((double)q);
if (ind<indmax-1) { /* lift root */
h=lifts[ind];
while (h<q*p) {
if (pol_eval(q*p,deg,assess_mod,h)==0) break;
h+=q;
}
if (h<q*p) {
ind++; lifts[ind]=h;
continue;
} /* did not find lift */
} /* find next lift or go back */
while (ind>=0) {
q=powers[ind]; q0=q/p;
h=lifts[ind]+q0;
while (h<q) {
if (pol_eval(q,deg,assess_mod,h)==0) break;
h+=q0;
}
lifts[ind]=h;
if (h<q) break; /* found another zero */
ind--;
}
if (ind>0) continue;
break; /* finished */
}
return res;
}
/*
* === FUNCTION ======================================================================
* Name: convertToChar
* Description:
* =====================================================================================
*/
char *convertToChar(mpz_t *arr, int arr_size, int block_size, int *ret_size) {
char *result;
int res_size = arr_size * block_size + 1, i, j;
result = (char *) malloc (sizeof(char) * res_size);
mpz_t tmp;
mpz_init(tmp);
for (i=0; i<arr_size; i++) {
mpz_set(tmp, arr[i]);
for (j=0; j<block_size; j++) {
result[block_size - 1 - j + i *block_size] = (char) mpz_fdiv_ui(tmp, NB_CHAR);
mpz_fdiv_q_ui(tmp, tmp, NB_CHAR);
}
}
*ret_size = res_size;
result[res_size - 1] = '\0';
return result;
} /* ----- end of function convertToChar ----- */
/// @jakob: overflow can be occured due to multiplication. use exact mpz for multiply and modulo operation instead!
void ARingGF::power(ElementType &result, const ElementType a, const STT n) const
{
if (givaroField.isnzero(a))
{
mpz_t mpz_a;
mpz_t mpz_n;
mpz_t mpz_tmp;
mpz_init( mpz_a);
mpz_init( mpz_n);
mpz_init( mpz_tmp);
mpz_set_si (mpz_n,n);
mpz_set_ui (mpz_a,a);
//std::cerr << "a = " << a << std::endl;
//std::cerr << "mpz_a = " << mpz_a << std::endl;
//std::cerr << "n = " << n << std::endl;
//std::cerr << "mpz_n = " << mpz_n << std::endl;
mpz_fdiv_r_ui(mpz_tmp, mpz_n, givaroField.cardinality() -1) ;
mpz_mul(mpz_n, mpz_a, mpz_tmp);
STT tmp = static_cast< STT>(mpz_fdiv_ui( mpz_n, givaroField.cardinality() -1)) ;
if ( tmp==0 )
{
tmp+=givaroField.cardinality()-1;
// result=givaroField.one;
}
//std::cerr << "tmp = " << tmp << std::endl;
assert(tmp>=0); // tmp<0 should never occur
if (tmp < 0) tmp += givaroField.cardinality()-1 ;
result = tmp;
}
else
{
if (n<0)
ERROR(" division by zero");
result = 0;
}
}
/* evaluate the Knuth-Schroeppel function, cf Robert D. Silverman,
"The Multiple Polynomial Quadratic Sieve", Math. of Comp. volume 48,
number 177, 1987, page 335 */
unsigned long
find_multiplier (mpz_t N, double B)
{
unsigned long k, bestk = 1;
double p, f, g, maxf = 0.0;
mpz_t kN;
mpz_init (kN);
for (k = 1; k < 100; k = nextprime (k))
{
mpz_mul_ui (kN, N, k);
/* FIXME: Silverman writes "if N = 1 mod 8" but isn't it kN instead? */
if (mpz_kronecker_ui (kN, 2) == 1 && mpz_fdiv_ui (kN, 8) == 1)
f = 2.0 * log (2.0);
else
f = 0.0;
for (p = getprime (2.0); p <= B; p = getprime (p))
{
if (mpz_kronecker_ui (kN, (unsigned long) p) == 1)
{
g = ((k % (unsigned long) p) == 0) ? (1.0 / p) : (2.0 / p);
f += g * log (p);
}
}
f -= 0.5 * log ((double) k);
if (f > maxf)
{
maxf = f;
bestk = k;
}
getprime (0.0); /* free prime buffer */
}
mpz_clear (kN);
return bestk;
}
DUPFF DMPZ_to_DUPFF(DMPZ f, int var, int *substitution)
{
FFelem p = CurrentFF.prime;
int df, d, c, i;
DUPFF ans;
DMPZ iter;
df = DMPZdeg(f, var);
ans = DUPFFnew(df);
for(i=0; i<=df;i++) ans->coeffs[i] = 0;
for(iter=f;iter;iter = iter->next)
{
d = iter->exps[var];
c = mpz_fdiv_ui(iter->coeff, p);
for(i=0; c!=0 && i<NVARS;i++)
if (i != var)
c = FFmul(c, FFpow(substitution[i], iter->exps[i]));
ans->coeffs[d] += c;
if (ans->coeffs[d] >= p) ans->coeffs[d] -= p;
}
for(i=df;i>=0;i--) if (ans->coeffs[i] != 0) break;
ans->deg = i;
return ans;
}
int main(int argc, char **argv)
{
mpz_t min, rop, sievesize;
unsigned long r;
unsigned long loop_count = 0;
FILE *fp = stdout;
bool *sieve[128];
int *primes, *primes_start, *sieve_loc;
size_t prime_size, loc_size;
mpz_init(min);
mpz_init(rop);
mpz_init(sievesize);
mpz_set_str(min, argv[1], 0);
mpz_set_ui(sievesize, SIEVESIZE);
r = mpz_fdiv_ui(min, PRIMORAL);
r = (97 - r + PRIMORAL) % PRIMORAL;
mpz_add_ui(rop, min, r);
primes_start =
(int *) primesieve_generate_primes(0, MAX_SIEVE_PRIME, &prime_size,
INT_PRIMES);
for (primes = primes_start; *primes <= 7; primes++);
prime_size -= (primes - primes_start);
//loc_size = 6 * prime_size;
loc_size = 8 * prime_size; //padding
sieve_loc = (int *) malloc(sizeof(int) * loc_size);
struct timeval start_t;
struct timeval end_t;
gettimeofday(&start_t, NULL);
#pragma omp parallel
{
mpz_t candidate_plus;
mpz_init(candidate_plus);
int tid = omp_get_thread_num();
sieve[tid] = (bool *) malloc(sizeof(bool) * SIEVESIZE);
if(sieve[tid]==NULL)
printf("%d nil\n", tid);
memset(sieve[tid], true, SIEVESIZE);
#pragma omp for schedule(static, 16)
for (int i = 0; i < prime_size; i++) {
//printf("%d:%d\n",tid,i);
int p = primes[i];
int inv = modinv_i(PRIMORAL, p);
for (int j = 0; j < 6; j++) {
mpz_add_ui(candidate_plus, rop, offsets[j]);
unsigned long cmodp = mpz_fdiv_ui(candidate_plus, p);
int index = ((p - cmodp) * inv) % p;
sieve_loc[i * 8 + j] = index;
}
}
mpz_clear(candidate_plus);
}
gettimeofday(&end_t, NULL);
float duration =
(end_t.tv_sec - start_t.tv_sec) * 1E6 + (end_t.tv_usec -
start_t.tv_usec);
printf("running time:%f\n", duration);
mpz_t tmp[4];
mpz_t candidate[4];
mpz_init(tmp[0]);
mpz_init(tmp[1]);
mpz_init(tmp[2]);
mpz_init(tmp[3]);
mpz_init(candidate[0]);
mpz_init(candidate[1]);
mpz_init(candidate[2]);
mpz_init(candidate[3]);
while (1) {
//step 1
//printf("Sieving\n");
gettimeofday(&start_t, NULL);
for (int i = 0; i < prime_size; i++) {
//printf("thread %d:prime%d\n", tid, primes[i]);
for (int j = 0; j < 6; j++) {
//o = sieve_loc[sieve_loc_index];
unsigned int o = sieve_loc[8 * i + j];
while (o < SIEVESIZE) {
sieve[0][o] = false;
o += primes[i];
}
sieve_loc[8 * i + j] = o - SIEVESIZE;
}
}
/*for(int i=0;i<SIEVESIZE;i++)
if(sieve[0][i])
printf("1\n");
else
printf("0\n");
for(int i=0;i<prime_size;i++){
for(int j=0;j<6;j++)
printf("%d:%d\n",primes[i], sieve_loc[8*i+j]);
}
break;*/
gettimeofday(&end_t, NULL);
duration =
(end_t.tv_sec - start_t.tv_sec) * 1E6 + (end_t.tv_usec -
start_t.tv_usec);
printf("running time1:%f\n", duration);
gettimeofday(&start_t, NULL);
#pragma omp parallel
{
int tid = omp_get_thread_num();
//int num = omp_get_num_threads();
/*#pragma omp for
for (int i = 0; i < prime_size; i++) {
//printf("thread %d:prime%d\n", tid, primes[i]);
for (int j = 0; j < 6; j++) {
//o = sieve_loc[sieve_loc_index];
unsigned int o = sieve_loc[8 * i + j];
while (o < SIEVESIZE) {
sieve[tid][o] = false;
o += primes[i];
}
sieve_loc[8 * i + j] = o - SIEVESIZE;
}
}*/
//#pragma omp barrier
#pragma omp for
for (int i = 0; i < SIEVESIZE; i++) {
/*bool flag = true;
for (int j = 0; j < num; j++) {
flag = flag && sieve[j][i];
sieve[j][i] = true;
}*/
if (sieve[0][i]) {
mpz_set_ui(tmp[tid], i);
mpz_addmul_ui(tmp[tid], sievesize, loop_count);
mpz_set(candidate[tid], rop);
mpz_addmul_ui(candidate[tid], tmp[tid], PRIMORAL);
if (is_fermat_valid(candidate[tid])) {
mpz_out_str(fp, 16, candidate[tid]);
exit(0);
}
}
//printf("thread %d:i%d\n", tid, i);
if(!sieve[0][i])
sieve[0][i] = true;
}
/*#pragma omp barrier
#pragma omp for
for (int i = 0; i < prime_size; i++) {
for (int j = 0; j < 6; j++)
sieve[tid][i*8+j]=true;
}*/
}
gettimeofday(&end_t, NULL);
duration =
(end_t.tv_sec - start_t.tv_sec) * 1E6 + (end_t.tv_usec -
start_t.tv_usec);
printf("running time2:%f\n", duration);
loop_count++;
}
return 0;
}
/// @pre ensure that mFfpackField.cardinality() fits in a unsigned long, otherwise instead of mpz_fdiv_ui a different function has to be called)
void ARingZZpFFPACK::power_mpz(ElementType &result, const ElementType a, const mpz_ptr n) const
{
STT n1 = static_cast< STT>(mpz_fdiv_ui(n, mFfpackField.cardinality()-1));
power(result,a,n1);
}
void ARingZZpFFPACK::set_from_mpz(ElementType &result, const mpz_ptr a) const
{
unsigned long b = static_cast<UTT>(mpz_fdiv_ui(a, mCharac));
mFfpackField.init(result, b );
}
void power_mpz(elem &result, elem a, mpz_ptr n) const
{
int n1 = static_cast<int>(mpz_fdiv_ui(n, p1));
power(result, a, n1);
}
void set_from_mpz(elem &result, mpz_srcptr a) const
{
int b = static_cast<int>(mpz_fdiv_ui(a, p));
result = log_table[b];
}
void set_from_mpz(ElementType& result, mpz_srcptr a) const
{
int b = static_cast<int>(mpz_fdiv_ui(a, characteristic()));
set_from_long(result, b);
}
void* worker(void* arg)
{
State& state = *((State*) arg);
long k = state.k;
#ifdef USE_THREADS
pthread_mutex_lock(&state.lock);
#endif
while (1)
{
if (state.next * BLOCK_SIZE < state.bound)
{
// need to generate more modular data
long next = state.next++;
#ifdef USE_THREADS
pthread_mutex_unlock(&state.lock);
#endif
Item* item = new Item;
mpz_set_ui(item->modulus, 1);
mpz_set_ui(item->residue, 0);
for (long p = max(5, state.table->next_prime(next * BLOCK_SIZE));
p < state.bound && p < (next+1) * BLOCK_SIZE;
p = state.table->next_prime(p))
{
if (k % (p-1) == 0)
continue;
// compute B_k mod p
long b = bern_modp(p, k);
// CRT into running total
long x = MulMod(SubMod(b, mpz_fdiv_ui(item->residue, p), p),
InvMod(mpz_fdiv_ui(item->modulus, p), p), p);
mpz_addmul_ui(item->residue, item->modulus, x);
mpz_mul_ui(item->modulus, item->modulus, p);
}
#ifdef USE_THREADS
pthread_mutex_lock(&state.lock);
#endif
state.items.insert(item);
}
else
{
// all modular data has been generated
if (state.items.size() <= 1)
{
// no more CRTs for this thread to perform
#ifdef USE_THREADS
pthread_mutex_unlock(&state.lock);
#endif
return NULL;
}
// CRT two smallest items together
Item* item1 = *(state.items.begin());
state.items.erase(state.items.begin());
Item* item2 = *(state.items.begin());
state.items.erase(state.items.begin());
#ifdef USE_THREADS
pthread_mutex_unlock(&state.lock);
#endif
Item* item3 = CRT(item1, item2);
delete item1;
delete item2;
#ifdef USE_THREADS
pthread_mutex_lock(&state.lock);
#endif
state.items.insert(item3);
}
}
}
/* return NULL if an error occurred */
pp1_roots_state_t *
pp1_rootsG_init (mpres_t *x, root_params_t *root_params, mpmod_t modulus)
{
mpres_t P;
pp1_roots_state_t *state;
progression_params_t *params; /* for less typing */
unsigned long i;
ASSERT (gcd (root_params->d1, root_params->d2) == 1);
state = (pp1_roots_state_t *) malloc (sizeof (pp1_roots_state_t));
if (state == NULL)
return NULL;
params = &(state->params);
/* we don't need the sign anymore after pp1_rootsG_init */
params->S = ABS(root_params->S);
if (params->S == 1)
{
mpz_t t;
mpz_init (t);
mpres_init (P, modulus);
for (i = 0; i < 4; i++)
mpres_init (state->tmp[i], modulus);
params->dsieve = root_params->d2; /* needed in pp1_rootsG */
/* We want to skip values where gcd((i0 + i) * d1, d2) != 1.
We can test for gcd(i0 + i, d2) instead and let pp1_rootsG()
advance params->rsieve in steps of 1 */
/* params->rsieve = i0 % d2 */
params->rsieve = mpz_fdiv_ui (root_params->i0, root_params->d2);
outputf (OUTPUT_DEVVERBOSE, "pp1_rootsG_init: i0 = %Zd, state: "
"dsieve = %d, rsieve = %d, S = %d\n", root_params->i0,
params->dsieve, params->rsieve, params->S);
mpz_set_ui (t, root_params->d1);
pp1_mul (state->tmp[1], *x, t, modulus, state->tmp[3], P);
pp1_mul (state->tmp[0], state->tmp[1], root_params->i0, modulus,
state->tmp[3], P);
mpz_sub_ui (t, root_params->i0, 1);
mpz_abs (t, t);
pp1_mul (state->tmp[2], state->tmp[1], t, modulus, state->tmp[3], P);
/* for P+1, tmp[0] = V_s(P), tmp[1] = V_d1(P), tmp[2] = V_{|s-d1|}(P) */
mpres_clear (P, modulus);
mpz_clear (t);
}
else
{
listz_t coeffs;
params->dickson_a = (root_params->S < 0) ? -1 : 0;
params->nr = (root_params->d2 > 1) ? root_params->d2 - 1 : 1;
params->size_fd = params->nr * (params->S + 1);
params->next = 0;
params->dsieve = 1;
params->rsieve = 1;
state->fd = (point *) malloc (params->size_fd * sizeof (point));
if (state->fd == NULL)
{
free (state);
return NULL;
}
coeffs = init_progression_coeffs (root_params->i0, root_params->d2,
root_params->d1, 1, 1, params->S, params->dickson_a);
if (coeffs == NULL)
{
free (state->fd);
free (state);
return NULL;
}
for (i = 0; i < params->size_fd; i++)
{
mpres_init (state->fd[i].x, modulus);
mpres_init (state->fd[i].y, modulus);
/* The S-th coeff of all progressions is identical */
if (i > params->S && i % (params->S + 1) == params->S)
{
/* Simply copy from the first progression */
mpres_set (state->fd[i].x, state->fd[params->S].x, modulus);
mpres_set (state->fd[i].y, state->fd[params->S].y, modulus);
}
else
pp1_mul2 (state->fd[i].x, state->fd[i].y, x[0], coeffs[i], modulus);
}
clear_list (coeffs, params->size_fd);
}
return state;
}
