void quotient_mod_f(const Ptr<RCP<const Integer>> &q,
const Ptr<RCP<const Integer>> &r, const Integer &n,
const Integer &d)
{
integer_class _q, _r;
mp_fdiv_qr(_q, _r, n.as_integer_class(), d.as_integer_class());
*q = integer(std::move(_q));
*r = integer(std::move(_r));
}
int mod_inverse(const Ptr<RCP<const Integer>> &b, const Integer &a,
const Integer &m)
{
int ret_val;
integer_class inv_t;
ret_val = mp_invert(inv_t, a.as_integer_class(), m.as_integer_class());
*b = integer(std::move(inv_t));
return ret_val;
}
void gcd_ext(const Ptr<RCP<const Integer>> &g, const Ptr<RCP<const Integer>> &s,
const Ptr<RCP<const Integer>> &t, const Integer &a,
const Integer &b)
{
integer_class g_, s_, t_;
mp_gcdext(g_, s_, t_, a.as_integer_class(), b.as_integer_class());
*g = integer(std::move(g_));
*s = integer(std::move(s_));
*t = integer(std::move(t_));
}
void prime_factor_multiplicities(map_integer_uint &primes_mul, const Integer &n)
{
integer_class sqrtN;
integer_class _n = n.as_integer_class();
unsigned count;
if (_n == 0)
return;
if (_n < 0)
_n *= -1;
sqrtN = mp_sqrt(_n);
auto limit = mp_get_ui(sqrtN);
if (not mp_fits_ulong_p(sqrtN)
or limit > std::numeric_limits<unsigned>::max())
throw SymEngineException("N too large to factor");
Sieve::iterator pi(limit);
unsigned p;
while ((p = pi.next_prime()) <= limit) {
count = 0;
while (_n % p == 0) { // when a prime factor is found, we divide
++count; // _n by that prime as much as we can
_n = _n / p;
}
if (count > 0) {
insert(primes_mul, integer(p), count);
if (_n == 1)
break;
}
}
if (not(_n == 1))
insert(primes_mul, integer(std::move(_n)), 1);
}
bool primitive_root(const Ptr<RCP<const Integer>> &g, const Integer &n)
{
integer_class _n = n.as_integer_class();
if (_n < 0)
_n = -_n;
if (_n <= 1)
return false;
if (_n < 5) {
*g = integer(_n - 1);
return true;
}
bool even = false;
if (_n % 2 == 0) {
if (_n % 4 == 0) {
return false; // If n mod 4 == 0 and n > 4, then no primitive roots.
}
_n /= 2;
even = true;
}
integer_class p, e;
if (not _prime_power(p, e, _n))
return false;
_primitive_root(_n, p, e, even);
*g = integer(std::move(_n));
return true;
}
void primitive_root_list(std::vector<RCP<const Integer>> &roots,
const Integer &n)
{
integer_class _n = n.as_integer_class();
if (_n < 0)
_n = -_n;
if (_n <= 1)
return;
if (_n < 5) {
roots.push_back(integer(_n - 1));
return;
}
bool even = false;
if (_n % 2 == 0) {
if (_n % 4 == 0) {
return; // If n%4 == 0 and n > 4, then no primitive roots.
}
_n /= 2;
even = true;
}
integer_class p, e;
if (not _prime_power(p, e, _n))
return;
_primitive_root_list(roots, p, e, even);
std::sort(roots.begin(), roots.end(), SymEngine::RCPIntegerKeyLess());
return;
}
void prime_factors(std::vector<RCP<const Integer>> &prime_list,
const Integer &n)
{
integer_class sqrtN;
integer_class _n = n.as_integer_class();
if (_n == 0)
return;
if (_n < 0)
_n *= -1;
sqrtN = mp_sqrt(_n);
auto limit = mp_get_ui(sqrtN);
if (not mp_fits_ulong_p(sqrtN)
or limit > std::numeric_limits<unsigned>::max())
throw SymEngineException("N too large to factor");
Sieve::iterator pi(limit);
unsigned p;
while ((p = pi.next_prime()) <= limit) {
while (_n % p == 0) {
prime_list.push_back(integer(p));
_n = _n / p;
}
if (_n == 1)
break;
}
if (not(_n == 1))
prime_list.push_back(integer(std::move(_n)));
}
int factor_lehman_method(const Ptr<RCP<const Integer>> &f, const Integer &n)
{
int ret_val;
integer_class rop;
ret_val = _factor_lehman_method(rop, n.as_integer_class());
*f = integer(std::move(rop));
return ret_val;
}
int factor_trial_division(const Ptr<RCP<const Integer>> &f, const Integer &n)
{
int ret_val;
integer_class factor;
ret_val = _factor_trial_division_sieve(factor, n.as_integer_class());
if (ret_val == 1)
*f = integer(std::move(factor));
return ret_val;
}
int factor_pollard_pm1_method(const Ptr<RCP<const Integer>> &f,
const Integer &n, unsigned B, unsigned retries)
{
int ret_val = 0;
integer_class rop, nm4, c;
gmp_randstate_t state;
gmp_randinit_default(state);
gmp_randseed_ui(state, retries);
nm4 = n.as_integer_class() - 4;
for (unsigned i = 0; i < retries and ret_val == 0; ++i) {
mp_urandomm(c, state, nm4);
c = c + 2;
ret_val = _factor_pollard_pm1_method(rop, n.as_integer_class(), c, B);
}
if (ret_val != 0)
*f = integer(std::move(rop));
gmp_randclear(state);
return ret_val;
}
// Factorization
int factor(const Ptr<RCP<const Integer>> &f, const Integer &n, double B1)
{
int ret_val = 0;
integer_class _n, _f;
_n = n.as_integer_class();
#ifdef HAVE_SYMENGINE_ECM
if (mp_perfect_power_p(_n)) {
unsigned long int i = 1;
integer_class m, rem;
rem = 1; // Any non zero number
m = 2; // set `m` to 2**i, i = 1 at the begining
// calculate log2n, this can be improved
for (; m < _n; ++i)
m = m * 2;
// eventually `rem` = 0 zero as `n` is a perfect power. `f_t` will
// be set to a factor of `n` when that happens
while (i > 1 and rem != 0) {
mp_rootrem(_f, rem, _n, i);
--i;
}
ret_val = 1;
} else {
if (mp_probab_prime_p(_n, 25) > 0) { // most probably, n is a prime
ret_val = 0;
_f = _n;
} else {
for (int i = 0; i < 10 and not ret_val; ++i)
ret_val = ecm_factor(get_mpz_t(_f), get_mpz_t(_n), B1, nullptr);
mp_demote(_f);
if (not ret_val)
throw SymEngineException(
"ECM failed to factor the given number");
}
}
#else
// B1 is discarded if gmp-ecm is not installed
ret_val = _factor_trial_division_sieve(_f, _n);
#endif // HAVE_SYMENGINE_ECM
*f = integer(std::move(_f));
return ret_val;
}
int i_nth_root(const Ptr<RCP<const Integer>> &r, const Integer &a,
unsigned long int n)
{
if (n == 0)
throw SymEngineException("i_nth_root: Can not find Zeroth root");
int ret_val;
integer_class t;
ret_val = mp_root(t, a.as_integer_class(), n);
*r = integer(std::move(t));
return ret_val;
}
int factor_pollard_rho_method(const Ptr<RCP<const Integer>> &f,
const Integer &n, unsigned retries)
{
int ret_val = 0;
integer_class rop, nm1, nm4, a, s;
gmp_randstate_t state;
gmp_randinit_default(state);
gmp_randseed_ui(state, retries);
nm1 = n.as_integer_class() - 1;
nm4 = n.as_integer_class() - 4;
for (unsigned i = 0; i < retries and ret_val == 0; ++i) {
mp_urandomm(a, state, nm1);
mp_urandomm(s, state, nm4);
s = s + 1;
ret_val = _factor_pollard_rho_method(rop, n.as_integer_class(), a, s);
}
if (ret_val != 0)
*f = integer(std::move(rop));
gmp_randclear(state);
return ret_val;
}
// Returns true if `b` divides `a` without reminder
bool divides(const Integer &a, const Integer &b)
{
return mp_divisible_p(a.as_integer_class(), b.as_integer_class()) != 0;
}
// Prime functions
int probab_prime_p(const Integer &a, unsigned reps)
{
return mp_probab_prime_p(a.as_integer_class(), reps);
}
RCP<const Integer> quotient_f(const Integer &n, const Integer &d)
{
integer_class q;
mp_fdiv_q(q, n.as_integer_class(), d.as_integer_class());
return integer(std::move(q));
}
RCP<const Integer> quotient(const Integer &n, const Integer &d)
{
return integer(n.as_integer_class() / d.as_integer_class());
}
RCP<const Integer> lcm(const Integer &a, const Integer &b)
{
integer_class c;
mp_lcm(c, a.as_integer_class(), b.as_integer_class());
return integer(std::move(c));
}
bool perfect_square(const Integer &n)
{
return mp_perfect_square_p(n.as_integer_class());
}
int kronecker(const Integer &a, const Integer &n)
{
return mp_kronecker(a.as_integer_class(), n.as_integer_class());
}
int legendre(const Integer &a, const Integer &n)
{
return mp_legendre(a.as_integer_class(), n.as_integer_class());
}
int jacobi(const Integer &a, const Integer &n)
{
return mp_jacobi(a.as_integer_class(), n.as_integer_class());
}
RCP<const Integer> isqrt(const Integer &n)
{
return integer(mp_sqrt(n.as_integer_class()));
}
// Binomial Coefficient
RCP<const Integer> binomial(const Integer &n, unsigned long k)
{
integer_class f;
mp_bin_ui(f, n.as_integer_class(), k);
return integer(std::move(f));
}
RCP<const Integer> mod(const Integer &n, const Integer &d)
{
return integer(n.as_integer_class() % d.as_integer_class());
}
bool perfect_power(const Integer &n)
{
return mp_perfect_power_p(n.as_integer_class());
}
RCP<const Integer> nextprime(const Integer &a)
{
integer_class c;
mp_nextprime(c, a.as_integer_class());
return integer(std::move(c));
}
RCP<const Integer> iabs(const Integer &n)
{
return integer(mp_abs(n.as_integer_class()));
}
fqp_t URatPSeriesFlint::convert(const Integer &x)
{
return convert(x.as_integer_class());
}
