void
dlog_rho_init(dlog_rho_t t, ulong a, ulong mod, ulong n)
{
t->a = a;
nmod_init(&t->n, n);
nmod_init(&t->mod, mod);
t->nisprime = n_is_prime(n);
}
int main(void)
{
int i, result;
ulong count = 0UL;
flint_rand_t state;
flint_randinit(state);
printf("factor_SQUFOF....");
fflush(stdout);
for (i = 0; i < 3000; i++) /* Test random numbers */
{
mp_limb_t n1, n2;
do
{
n1 = n_randbits(state, n_randint(state, FLINT_BITS) + 1);
} while (n_is_prime(n1) || (n1 < 2UL));
#if FLINT64
n2 = n_factor_SQUFOF(n1, 10000);
#else
n2 = n_factor_SQUFOF(n1, 2000);
#endif
if (n2)
{
count++;
result = ((n1%n2) == 0UL);
if (!result)
{
printf("FAIL:\n");
printf("n1 = %lu, n2 = %lu\n", n1, n2);
abort();
}
}
}
if (count < 2800)
{
printf("FAIL:\n");
printf("Only %lu of 10000 numbers factored\n", count);
abort();
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
void
_arith_cos_minpoly(fmpz * coeffs, slong d, ulong n)
{
slong i, j;
fmpz * alpha;
fmpz_t half;
mpfr_t t, u;
mp_bitcnt_t prec;
slong exp;
if (n <= MAX_32BIT)
{
for (i = 0; i <= d; i++)
fmpz_set_si(coeffs + i, lookup_table[n - 1][i]);
return;
}
/* Direct formula for odd primes > 3 */
if (n_is_prime(n))
{
slong s = (n - 1) / 2;
switch (s % 4)
{
case 0:
fmpz_set_si(coeffs, WORD(1));
fmpz_set_si(coeffs + 1, -s);
break;
case 1:
fmpz_set_si(coeffs, WORD(1));
fmpz_set_si(coeffs + 1, s + 1);
break;
case 2:
fmpz_set_si(coeffs, WORD(-1));
fmpz_set_si(coeffs + 1, s);
break;
case 3:
fmpz_set_si(coeffs, WORD(-1));
fmpz_set_si(coeffs + 1, -s - 1);
break;
}
for (i = 2; i <= s; i++)
{
slong b = (s - i) % 2;
fmpz_mul2_uiui(coeffs + i, coeffs + i - 2, s+i-b, s+2-b-i);
fmpz_divexact2_uiui(coeffs + i, coeffs + i, i, i-1);
fmpz_neg(coeffs + i, coeffs + i);
}
return;
}
prec = magnitude_bound(d) + 5 + FLINT_BIT_COUNT(d);
alpha = _fmpz_vec_init(d);
fmpz_init(half);
mpfr_init2(t, prec);
mpfr_init2(u, prec);
fmpz_one(half);
fmpz_mul_2exp(half, half, prec - 1);
mpfr_const_pi(t, prec);
mpfr_div_ui(t, t, n, MPFR_RNDN);
for (i = j = 0; j < d; i++)
{
if (n_gcd(n, i) == 1)
{
mpfr_mul_ui(u, t, 2 * i, MPFR_RNDN);
mpfr_cos(u, u, MPFR_RNDN);
mpfr_neg(u, u, MPFR_RNDN);
exp = mpfr_get_z_2exp(_fmpz_promote(alpha + j), u);
_fmpz_demote_val(alpha + j);
fmpz_mul_or_div_2exp(alpha + j, alpha + j, exp + prec);
j++;
}
}
balanced_product(coeffs, alpha, d, prec);
/* Scale and round */
for (i = 0; i < d + 1; i++)
{
slong r = d;
if ((n & (n - 1)) == 0)
r--;
fmpz_mul_2exp(coeffs + i, coeffs + i, r);
fmpz_add(coeffs + i, coeffs + i, half);
fmpz_fdiv_q_2exp(coeffs + i, coeffs + i, prec);
}
fmpz_clear(half);
mpfr_clear(t);
mpfr_clear(u);
_fmpz_vec_clear(alpha, d);
}
mp_limb_t n_nextprime(mp_limb_t n, int proved)
{
mp_limb_t * moduli;
ulong i, index;
if (n < 7)
{
if (n < 2)
return 2;
n++;
n |= 1;
return n;
}
if (n >= UWORD_MAX_PRIME)
{
flint_printf("Exception (n_nextprime). No larger single-limb prime exists.\n");
abort();
}
index = n % 30;
n += nextmod30[index];
index = nextindex[index];
if (n <= flint_primes_small[NEXTPRIME_PRIMES-1])
{
if (n == 7) return 7;
if (n == 11) return 11;
if (n == 13) return 13;
while (((n % 7) == 0) || ((n % 11) == 0) || ((n % 13) == 0))
{
n += nextmod30[index];
index = nextindex[index];
}
return n;
}
moduli = (mp_limb_t *) flint_malloc(NEXTPRIME_PRIMES * sizeof(mp_limb_t));
for (i = 3; i < NEXTPRIME_PRIMES; i++)
moduli[i] = (n % flint_primes_small[i]);
while (1)
{
ulong composite = 0;
ulong diff, acc, pr;
diff = nextmod30[index];
/* First check residues */
for (i = 3; i < NEXTPRIME_PRIMES; i++)
{
composite |= (moduli[i] == 0);
acc = moduli[i] + diff;
pr = flint_primes_small[i];
moduli[i] = acc >= pr ? acc - pr : acc;
}
if (composite)
{
n += diff;
index = nextindex[index];
continue;
}
if ((!proved && n_is_probabprime(n)) || (proved && n_is_prime(n)))
{
break;
}
else
{
n += diff;
index = nextindex[index];
}
}
flint_free(moduli);
return n;
}
int main(void)
{
int i, result;
flint_rand_t state;
mp_limb_t d;
mpz_t d_m;
printf("is_prime....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++) /* Test that primes pass the test */
{
mpz_init(d_m);
do
{
d = n_randtest(state) | 1;
mpz_set_ui(d_m, d);
mpz_nextprime(d_m, d_m);
d = mpz_get_ui(d_m);
} while (mpz_size(d_m) > 1);
result = n_is_prime(d);
if (!result)
{
printf("FAIL:\n");
printf("d = %lu is declared composite\n", d);
abort();
}
mpz_clear(d_m);
}
for (i = 0; i < 100000; i++) /* Test that composites do not pass */
{
mpz_init(d_m);
do
{
d = n_randtest(state) | 1;
if (d == 1UL) d++;
mpz_set_ui(d_m, d);
} while (mpz_probab_prime_p(d_m, 12));
result = !n_is_prime(d);
if (!result)
{
printf("FAIL:\n");
printf("d = %lu is declared prime\n", d);
abort();
}
mpz_clear(d_m);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
