void qsieve_ll_compute_A_factor_offsets(qs_t qs_inf)
{
long s = qs_inf->s;
mp_limb_t * A_ind = qs_inf->A_ind;
mp_limb_t * A_modp = qs_inf->A_modp;
mp_limb_t * soln1 = qs_inf->soln1;
mp_limb_t * soln2 = qs_inf->soln2;
mp_limb_t p, D;
mp_limb_t hi = qs_inf->hi;
mp_limb_t lo = qs_inf->lo;
mp_limb_t B = qs_inf->B;
mp_limb_t temp, temp2, B_modp2, index, p2;
prime_t * factor_base = qs_inf->factor_base;
mp_limb_t * inv_p2 = qs_inf->inv_p2;
mp_limb_t pinv;
long j;
for (j = 0; j < s; j++)
{
index = A_ind[j];
p = factor_base[index].p;
p2 = p*p;
pinv = factor_base[index].pinv;
D = n_ll_mod_preinv(hi, lo, p*p, inv_p2[j]);
if ((mp_limb_signed_t) B < 0)
{
B_modp2 = n_mod2_preinv(-B, p2, inv_p2[j]);
B_modp2 = p2 - B_modp2;
if (B_modp2 == p2) B_modp2 = 0;
} else
B_modp2 = n_mod2_preinv(B, p2, inv_p2[j]);
temp = B_modp2*A_modp[j];
temp = n_mod2_preinv(temp, p, pinv);
temp2 = n_invmod(temp, p);
D -= (B_modp2*B_modp2);
if ((mp_limb_signed_t) D < 0)
temp = -(-D/p); /* TODO consider using precomputed inverse */
else
temp = (D/p); /* TODO consider using precomputed inverse */
temp *= temp2;
temp += qs_inf->sieve_size/2;
if ((mp_limb_signed_t) temp < 0)
{
temp = p - n_mod2_preinv(-temp, p, pinv);
if (temp == p) temp = 0;
}
else temp = n_mod2_preinv(temp, p, pinv);
soln1[index] = temp;
soln2[index] = -1;
}
}
void qsieve_ll_compute_B_terms(qs_t qs_inf)
{
long s = qs_inf->s;
mp_limb_t * A_ind = qs_inf->A_ind;
mp_limb_t * A_modp = qs_inf->A_modp;
mp_limb_t * B_terms = qs_inf->B_terms;
prime_t * factor_base = qs_inf->factor_base;
mp_limb_t A = qs_inf->A;
mp_limb_t B;
mp_limb_t p, temp, temp2, pinv;
long i;
for (i = 0; i < s; i++)
{
p = factor_base[A_ind[i]].p;
pinv = factor_base[A_ind[i]].pinv;
temp = A/p; /* TODO: possibly use precomputed inverse here */
A_modp[i] = (temp2 = n_mod2_preinv(temp, p, pinv));
temp2 = n_invmod(temp2, p);
temp2 = n_mulmod2_preinv(temp2, qs_inf->sqrts[A_ind[i]], p, pinv);
if (temp2 > p/2) temp2 = p - temp2;
B_terms[i] = temp*temp2;
}
B = B_terms[0];
for (i = 1; i < s; i++)
{
B += B_terms[i];
}
qs_inf->B = B;
}
static __inline__ mp_limb_t
nmod_set_si(long v, nmod_t mod)
{
mp_limb_t u = n_mod2_preinv(FLINT_ABS(v), mod.n, mod.ninv);
if (v < 0)
u = n_negmod(u, mod.n);
return u;
}
void qsieve_ll_compute_off_adj(qs_t qs_inf)
{
long num_primes = qs_inf->num_primes;
mp_limb_t A = qs_inf->A;
mp_limb_t B = qs_inf->B;
mp_limb_t * A_inv = qs_inf->A_inv;
mp_limb_t ** A_inv2B = qs_inf->A_inv2B;
mp_limb_t * B_terms = qs_inf->B_terms;
mp_limb_t * soln1 = qs_inf->soln1;
mp_limb_t * soln2 = qs_inf->soln2;
int * sqrts = qs_inf->sqrts;
prime_t * factor_base = qs_inf->factor_base;
long s = qs_inf->s;
mp_limb_t p, temp, pinv;
long i, j;
for (i = 2; i < num_primes; i++) /* skip k and 2 */
{
p = factor_base[i].p;
pinv = factor_base[i].pinv;
A_inv[i] = n_invmod(n_mod2_preinv(A, p, pinv), p);
for (j = 0; j < s; j++)
{
temp = n_mod2_preinv(B_terms[j], p, pinv);
temp = n_mulmod2_preinv(temp, A_inv[i], p, pinv);
temp *= 2;
if (temp >= p) temp -= p;
A_inv2B[j][i] = temp;
}
temp = n_mod2_preinv(B, p, pinv);
temp = sqrts[i] + p - temp;
temp *= A_inv[i];
temp += qs_inf->sieve_size/2;
soln1[i] = n_mod2_preinv(temp, p, pinv);
temp = p - sqrts[i];
if (temp == p) temp -= p;
temp = n_mulmod2_preinv(temp, A_inv[i], p, pinv);
temp *= 2;
if (temp >= p) temp -= p;
soln2[i] = temp + soln1[i];
if (soln2[i] >= p) soln2[i] -= p;
}
}
void
_nmod_poly_div_basecase_1(mp_ptr Q, mp_ptr W,
mp_srcptr A, long A_len, mp_srcptr B, long B_len,
nmod_t mod)
{
mp_limb_t lead_inv = n_invmod(B[B_len - 1], mod.n);
long len, coeff = A_len - B_len;
mp_ptr R1 = W;
mp_srcptr Btop = B + B_len - 1;
mpn_copyi(R1, A + B_len - 1, A_len - B_len + 1);
while (coeff >= 0)
{
R1[coeff] = n_mod2_preinv(R1[coeff], mod.n, mod.ninv);
while (coeff >= 0 && R1[coeff] == 0L)
{
Q[coeff--] = 0L;
if (coeff >= 0)
R1[coeff] = n_mod2_preinv(R1[coeff], mod.n, mod.ninv);
}
if (coeff >= 0)
{
mp_limb_t c, * R_sub;
Q[coeff] =
n_mulmod2_preinv(R1[coeff], lead_inv, mod.n, mod.ninv);
c = n_negmod(Q[coeff], mod.n);
len = FLINT_MIN(B_len - 1, coeff);
R_sub = R1 + coeff - len;
if (len > 0)
mpn_addmul_1(R_sub, Btop - len, len, c);
coeff--;
}
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("reduce....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
long j, len = n_randint(state, 100) + 1;
mp_ptr vec = _nmod_vec_init(len);
mp_ptr vec2 = _nmod_vec_init(len);
mp_limb_t n = n_randtest_not_zero(state);
nmod_t mod;
nmod_init(&mod, n);
for (j = 0; j < len; j++)
{
vec[j] = n_randtest(state);
vec2[j] = vec[j];
}
_nmod_vec_reduce(vec, vec, len, mod);
for (j = 0; j < len; j++)
vec2[j] = n_mod2_preinv(vec2[j], mod.n, mod.ninv);
result = _nmod_vec_equal(vec, vec2, len);
if (!_nmod_vec_equal(vec, vec2, len))
{
printf("FAIL:\n");
printf("len = %ld, n = %ld\n", len, n);
abort();
}
_nmod_vec_clear(vec);
_nmod_vec_clear(vec2);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
void _fq_nmod_trace(fmpz_t rop2, const mp_limb_t *op, slong len,
const fq_nmod_ctx_t ctx)
{
const slong d = fq_nmod_ctx_degree(ctx);
ulong i, l;
mp_limb_t *t, rop;
t = _nmod_vec_init(d);
_nmod_vec_zero(t, d);
t[0] = n_mod2_preinv(d, ctx->mod.n, ctx->mod.ninv);
for (i = 1; i < d; i++)
{
for (l = ctx->len - 2; l >= 0 && ctx->j[l] >= d - (i - 1); l--)
{
t[i] = n_addmod(t[i],
n_mulmod2_preinv(t[ctx->j[l] + i - d], ctx->a[l], ctx->mod.n, ctx->mod.ninv),
ctx->mod.n);
}
if (l >= 0 && ctx->j[l] == d - i)
{
t[i] = n_addmod(t[i],
n_mulmod2_preinv(ctx->a[l], i, ctx->mod.n, ctx->mod.ninv),
ctx->mod.n);
}
t[i] = n_negmod(t[i], ctx->mod.n);
}
rop = WORD(0);
for (i = 0; i < d; i++)
{
rop = n_addmod(rop,
n_mulmod2_preinv(op[i], t[i], ctx->mod.n, ctx->mod.ninv),
ctx->mod.n);
}
_nmod_vec_clear(t);
fmpz_set_ui(rop2, rop);
}
void
nmod_poly_exp_series_monomial_ui(nmod_poly_t res, mp_limb_t coeff,
ulong power, slong n)
{
if (n == 0)
{
nmod_poly_zero(res);
return;
}
if (coeff == UWORD(0))
{
nmod_poly_fit_length(res, 1);
res->coeffs[0] = UWORD(1);
res->length = 1;
return;
}
if (power == 0)
{
flint_printf("Exception (nmod_poly_exp_series_monomial_ui). \n"
"Constant term != 0.\n");
abort();
}
if (coeff != UWORD(1))
coeff = n_mod2_preinv(coeff, res->mod.n, res->mod.ninv);
if (n == 1 || power >= n)
{
nmod_poly_fit_length(res, 1);
res->coeffs[0] = UWORD(1);
res->length = 1;
}
nmod_poly_fit_length(res, n);
_nmod_poly_exp_series_monomial_ui(res->coeffs, coeff, power, n, res->mod);
res->length = n;
_nmod_poly_normalise(res);
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mod2_preinv....");
fflush(stdout);
for (i = 0; i < 100000 * flint_test_multiplier(); i++)
{
mp_limb_t d, dinv, n, r1, r2;
d = n_randtest_not_zero(state);
n = n_randtest(state);
dinv = n_preinvert_limb(d);
r1 = n_mod2_preinv(n, d, dinv);
r2 = n%d;
result = (r1 == r2);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n = %wu, d = %wu, dinv = %wu\n", n, d, dinv);
flint_printf("r1 = %wu, r2 = %wu\n", r1, r2);
abort();
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void fmpz_powm_ui(fmpz_t f, const fmpz_t g, ulong e, const fmpz_t m)
{
if (fmpz_sgn(m) <= 0)
{
printf("Exception (fmpz_powm_ui). Modulus is less than 1.\n");
abort();
}
if (fmpz_is_one(m))
{
fmpz_zero(f);
}
else if (e == 0)
{
fmpz_one(f);
}
else /* e != 0, m > 0 */
{
fmpz g2 = *g;
fmpz m2 = *m;
if (!COEFF_IS_MPZ(m2)) /* m is small */
{
if (!COEFF_IS_MPZ(g2)) /* g is small */
{
mp_limb_t minv = n_preinvert_limb(m2);
_fmpz_demote(f);
if (g2 >= 0)
{
g2 = n_mod2_preinv(g2, m2, minv);
*f = n_powmod2_preinv(g2, e, m2, minv);
}
else
{
g2 = n_mod2_preinv(-g2, m2, minv);
*f = n_powmod2_preinv(g2, e, m2, minv);
if ((e & 1UL))
*f = n_negmod(*f, m2);
}
}
else /* g is large */
{
__mpz_struct *ptr = _fmpz_promote(f);
mpz_t m3;
mpz_init_set_ui(m3, m2);
mpz_powm_ui(ptr, COEFF_TO_PTR(g2), e, m3);
mpz_clear(m3);
_fmpz_demote_val(f);
}
}
else /* m is large */
{
if (!COEFF_IS_MPZ(g2)) /* g is small */
{
__mpz_struct *ptr = _fmpz_promote(f);
mpz_t g3;
mpz_init_set_si(g3, g2);
mpz_powm_ui(ptr, g3, e, COEFF_TO_PTR(m2));
mpz_clear(g3);
_fmpz_demote_val(f);
}
else /* g is large */
{
__mpz_struct *ptr = _fmpz_promote(f);
mpz_powm_ui(ptr, COEFF_TO_PTR(g2), e, COEFF_TO_PTR(m2));
_fmpz_demote_val(f);
}
}
}
}
