// Basic number theoretic functions
RCP<const Integer> gcd(const Integer &a, const Integer &b)
{
mpz_class g;
mpz_gcd(g.get_mpz_t(), a.as_mpz().get_mpz_t(), b.as_mpz().get_mpz_t());
return integer(g);
}
void mod(const Ptr<RCP<const Number>> &r, const Integer &n, const Integer &d)
{
mpz_t inv_t;
mpz_init(inv_t);
mpz_mod(inv_t, n.as_mpz().get_mpz_t(), d.as_mpz().get_mpz_t());
*r = integer(mpz_class(inv_t));
}
void fdiv_q(const Ptr<RCP<const Integer>> &q, const Integer &n, const Integer &d)
{
mpz_t q_;
mpz_init(q_);
mpz_fdiv_q (q_, n.as_mpz().get_mpz_t(), d.as_mpz().get_mpz_t());
*q = integer(mpz_class(q_));
mpz_clear(q_);
}
RCP<const Integer> lcm(const Integer &a, const Integer &b)
{
mpz_class c;
mpz_lcm(c.get_mpz_t(), a.as_mpz().get_mpz_t(), b.as_mpz().get_mpz_t());
return integer(c);
}
int mod_inverse(const Ptr<RCP<const Integer>> &b, const Integer &a,
const Integer &m)
{
int ret_val;
mpz_t inv_t;
mpz_init(inv_t);
ret_val = mpz_invert(inv_t, a.as_mpz().get_mpz_t(), m.as_mpz().get_mpz_t());
*b = integer(mpz_class(inv_t));
mpz_clear(inv_t);
return ret_val;
}
// Binomial Coefficient
RCP<const Integer> binomial(const Integer &n, unsigned long k)
{
mpz_class f;
mpz_bin_ui(f.get_mpz_t(), n.as_mpz().get_mpz_t(), k);
return integer(f);
}
RCP<const Integer> nextprime(const Integer &a)
{
mpz_class c;
mpz_nextprime(c.get_mpz_t(), a.as_mpz().get_mpz_t());
return integer(c);
}
int factor_trial_division(const Ptr<RCP<const Integer>> &f, const Integer &n)
{
int ret_val;
mpz_class factor;
ret_val =_factor_trial_division_sieve(factor, n.as_mpz());
if (ret_val == 1) *f = integer(factor);
return ret_val;
}
int factor_lehman_method(const Ptr<RCP<const Integer>> &f, const Integer &n)
{
int ret_val;
mpz_class rop;
ret_val = _factor_lehman_method(rop, n.as_mpz());
*f = integer(rop);
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)
{
mpz_t g_t;
mpz_t s_t;
mpz_t t_t;
mpz_init(g_t);
mpz_init(s_t);
mpz_init(t_t);
mpz_gcdext(g_t, s_t, t_t, a.as_mpz().get_mpz_t(), b.as_mpz().get_mpz_t());
*g = integer(mpz_class(g_t));
*s = integer(mpz_class(s_t));
*t = integer(mpz_class(t_t));
mpz_clear(g_t);
mpz_clear(s_t);
mpz_clear(t_t);
}
int factor_pollard_pm1_method(const Ptr<RCP<const Integer>> &f, const Integer &n,
unsigned B, unsigned retries)
{
int ret_val = 0;
mpz_class rop, nm4, c;
gmp_randstate_t state;
gmp_randinit_default(state);
gmp_randseed_ui(state, retries);
nm4 = n.as_mpz() - 4;
for (unsigned i = 0; i < retries && ret_val == 0; i++) {
mpz_urandomm(c.get_mpz_t(), state, nm4.get_mpz_t());
c = c + 2;
ret_val = _factor_pollard_pm1_method(rop, n.as_mpz(), c, B);
}
if (ret_val != 0)
*f = integer(rop);
return ret_val;
}
RCP<const Integer> iabs(const Integer &n)
{
mpz_class m;
mpz_t m_t;
mpz_init(m_t);
mpz_abs(m_t, n.as_mpz().get_mpz_t());
m = mpz_class(m_t);
mpz_clear(m_t);
return integer(mpz_class(m));
}
int factor_pollard_rho_method(const Ptr<RCP<const Integer>> &f,
const Integer &n, unsigned retries)
{
int ret_val = 0;
mpz_class rop, nm1, nm4, a, s;
gmp_randstate_t state;
gmp_randinit_default(state);
gmp_randseed_ui(state, retries);
nm1 = n.as_mpz() - 1;
nm4 = n.as_mpz() - 4;
for (unsigned i = 0; i < retries && ret_val == 0; i++) {
mpz_urandomm(a.get_mpz_t(), state, nm1.get_mpz_t());
mpz_urandomm(s.get_mpz_t(), state, nm4.get_mpz_t());
s = s + 1;
ret_val = _factor_pollard_rho_method(rop, n.as_mpz(), a, s);
}
if (ret_val != 0)
*f = integer(rop);
return ret_val;
}
// Factorization
int factor(const Ptr<RCP<const Integer>> &f, const Integer &n, double B1)
{
int ret_val = 0;
mpz_class _n, _f;
_n = n.as_mpz();
#ifdef HAVE_CSYMPY_ECM
if (mpz_perfect_power_p(_n.get_mpz_t())) {
unsigned long int i = 1;
mpz_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 && rem != 0) {
mpz_rootrem(_f.get_mpz_t(), rem.get_mpz_t(), _n.get_mpz_t(), i);
i--;
}
ret_val = 1;
}
else {
if (mpz_probab_prime_p(_n.get_mpz_t(), 25) > 0) { // most probably, n is a prime
ret_val = 0;
_f = _n;
}
else {
for (int i = 0; i < 10 && !ret_val; i++)
ret_val = ecm_factor(_f.get_mpz_t(), _n.get_mpz_t(), B1, NULL);
if (!ret_val)
throw std::runtime_error("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_CSYMPY_ECM
*f = integer(_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 std::runtime_error("i_nth_root: Can not find Zeroth root");
int ret_val;
mpz_t t;
mpz_init(t);
ret_val = mpz_root(t, a.as_mpz().get_mpz_t(), n);
*r = integer(mpz_class(t));
mpz_clear(t);
return ret_val;
}
flint::fmpzxx URatPSeriesFlint::convert(const Integer &x) {
flint::fmpzxx r;
fmpz_set_mpz(r._data().inner, get_mpz_t(x.as_mpz()));
return r;
}
int perfect_power(const Integer &n)
{
return mpz_perfect_power_p(n.as_mpz().get_mpz_t());
}
int perfect_square(const Integer &n)
{
return mpz_perfect_square_p(n.as_mpz().get_mpz_t());
}
fqp_t URatPSeriesFlint::convert(const Integer &x)
{
return convert(x.as_mpz());
}
// Prime functions
int probab_prime_p(const Integer &a, int reps)
{
return mpz_probab_prime_p(a.as_mpz().get_mpz_t(), reps);
}
