### Files

``````/* Factoring with Pollard's rho method.

Copyright 1995, 1997-2003, 2005, 2009, 2012, 2015 Free Software
Foundation, Inc.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.  See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program.  If not, see https://www.gnu.org/licenses/.  */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>

#include "gmp.h"

static unsigned char primes_diff[] = {
#define P(a,b,c) a,
#include "primes.h"
#undef P
};
#define PRIMES_PTAB_ENTRIES (sizeof(primes_diff) / sizeof(primes_diff[0]))

int flag_verbose = 0;

/* Prove primality or run probabilistic tests.  */
int flag_prove_primality = 1;

/* Number of Miller-Rabin tests to run when not proving primality. */
#define MR_REPS 25

struct factors
{
mpz_t         *p;
unsigned long *e;
long nfactors;
};

void factor (mpz_t, struct factors *);

void
factor_init (struct factors *factors)
{
factors->p = malloc (1);
factors->e = malloc (1);
factors->nfactors = 0;
}

void
factor_clear (struct factors *factors)
{
int i;

for (i = 0; i < factors->nfactors; i++)
mpz_clear (factors->p[i]);

free (factors->p);
free (factors->e);
}

void
factor_insert (struct factors *factors, mpz_t prime)
{
long    nfactors  = factors->nfactors;
mpz_t         *p  = factors->p;
unsigned long *e  = factors->e;
long i, j;

/* Locate position for insert new or increment e.  */
for (i = nfactors - 1; i >= 0; i--)
{
if (mpz_cmp (p[i], prime) <= 0)
break;
}

if (i < 0 || mpz_cmp (p[i], prime) != 0)
{
p = realloc (p, (nfactors + 1) * sizeof p[0]);
e = realloc (e, (nfactors + 1) * sizeof e[0]);

mpz_init (p[nfactors]);
for (j = nfactors - 1; j > i; j--)
{
mpz_set (p[j + 1], p[j]);
e[j + 1] = e[j];
}
mpz_set (p[i + 1], prime);
e[i + 1] = 1;

factors->p = p;
factors->e = e;
factors->nfactors = nfactors + 1;
}
else
{
e[i] += 1;
}
}

void
factor_insert_ui (struct factors *factors, unsigned long prime)
{
mpz_t pz;

mpz_init_set_ui (pz, prime);
factor_insert (factors, pz);
mpz_clear (pz);
}

void
factor_using_division (mpz_t t, struct factors *factors)
{
mpz_t q;
unsigned long int p;
int i;

if (flag_verbose > 0)
{
printf ("[trial division] ");
}

mpz_init (q);

p = mpz_scan1 (t, 0);
mpz_fdiv_q_2exp (t, t, p);
while (p)
{
factor_insert_ui (factors, 2);
--p;
}

p = 3;
for (i = 1; i <= PRIMES_PTAB_ENTRIES;)
{
if (! mpz_divisible_ui_p (t, p))
{
p += primes_diff[i++];
if (mpz_cmp_ui (t, p * p) < 0)
break;
}
else
{
mpz_tdiv_q_ui (t, t, p);
factor_insert_ui (factors, p);
}
}

mpz_clear (q);
}

static int
mp_millerrabin (mpz_srcptr n, mpz_srcptr nm1, mpz_ptr x, mpz_ptr y,
mpz_srcptr q, unsigned long int k)
{
unsigned long int i;

mpz_powm (y, x, q, n);

if (mpz_cmp_ui (y, 1) == 0 || mpz_cmp (y, nm1) == 0)
return 1;

for (i = 1; i < k; i++)
{
mpz_powm_ui (y, y, 2, n);
if (mpz_cmp (y, nm1) == 0)
return 1;
if (mpz_cmp_ui (y, 1) == 0)
return 0;
}
return 0;
}

int
mp_prime_p (mpz_t n)
{
int k, r, is_prime;
mpz_t q, a, nm1, tmp;
struct factors factors;

if (mpz_cmp_ui (n, 1) <= 0)
return 0;

/* We have already casted out small primes. */
if (mpz_cmp_ui (n, (long) FIRST_OMITTED_PRIME * FIRST_OMITTED_PRIME) < 0)
return 1;

mpz_inits (q, a, nm1, tmp, NULL);

/* Precomputation for Miller-Rabin.  */
mpz_sub_ui (nm1, n, 1);

/* Find q and k, where q is odd and n = 1 + 2**k * q.  */
k = mpz_scan1 (nm1, 0);
mpz_tdiv_q_2exp (q, nm1, k);

mpz_set_ui (a, 2);

/* Perform a Miller-Rabin test, finds most composites quickly.  */
if (!mp_millerrabin (n, nm1, a, tmp, q, k))
{
is_prime = 0;
goto ret2;
}

if (flag_prove_primality)
{
/* Factor n-1 for Lucas.  */
mpz_set (tmp, nm1);
factor (tmp, &factors);
}

/* Loop until Lucas proves our number prime, or Miller-Rabin proves our
number composite.  */
for (r = 0; r < PRIMES_PTAB_ENTRIES; r++)
{
int i;

if (flag_prove_primality)
{
is_prime = 1;
for (i = 0; i < factors.nfactors && is_prime; i++)
{
mpz_divexact (tmp, nm1, factors.p[i]);
mpz_powm (tmp, a, tmp, n);
is_prime = mpz_cmp_ui (tmp, 1) != 0;
}
}
else
{
/* After enough Miller-Rabin runs, be content. */
is_prime = (r == MR_REPS - 1);
}

if (is_prime)
goto ret1;

mpz_add_ui (a, a, primes_diff[r]);	/* Establish new base.  */

if (!mp_millerrabin (n, nm1, a, tmp, q, k))
{
is_prime = 0;
goto ret1;
}
}

fprintf (stderr, "Lucas prime test failure.  This should not happen\n");
abort ();

ret1:
if (flag_prove_primality)
factor_clear (&factors);
ret2:
mpz_clears (q, a, nm1, tmp, NULL);

return is_prime;
}

void
factor_using_pollard_rho (mpz_t n, unsigned long a, struct factors *factors)
{
mpz_t x, z, y, P;
mpz_t t, t2;
unsigned long long k, l, i;

if (flag_verbose > 0)
{
printf ("[pollard-rho (%lu)] ", a);
}

mpz_inits (t, t2, NULL);
mpz_init_set_si (y, 2);
mpz_init_set_si (x, 2);
mpz_init_set_si (z, 2);
mpz_init_set_ui (P, 1);
k = 1;
l = 1;

while (mpz_cmp_ui (n, 1) != 0)
{
for (;;)
{
do
{
mpz_mul (t, x, x);
mpz_mod (x, t, n);
mpz_add_ui (x, x, a);

mpz_sub (t, z, x);
mpz_mul (t2, P, t);
mpz_mod (P, t2, n);

if (k % 32 == 1)
{
mpz_gcd (t, P, n);
if (mpz_cmp_ui (t, 1) != 0)
goto factor_found;
mpz_set (y, x);
}
}
while (--k != 0);

mpz_set (z, x);
k = l;
l = 2 * l;
for (i = 0; i < k; i++)
{
mpz_mul (t, x, x);
mpz_mod (x, t, n);
mpz_add_ui (x, x, a);
}
mpz_set (y, x);
}

factor_found:
do
{
mpz_mul (t, y, y);
mpz_mod (y, t, n);
mpz_add_ui (y, y, a);

mpz_sub (t, z, y);
mpz_gcd (t, t, n);
}
while (mpz_cmp_ui (t, 1) == 0);

mpz_divexact (n, n, t);	/* divide by t, before t is overwritten */

if (!mp_prime_p (t))
{
if (flag_verbose > 0)
{
printf ("[composite factor--restarting pollard-rho] ");
}
factor_using_pollard_rho (t, a + 1, factors);
}
else
{
factor_insert (factors, t);
}

if (mp_prime_p (n))
{
factor_insert (factors, n);
break;
}

mpz_mod (x, x, n);
mpz_mod (z, z, n);
mpz_mod (y, y, n);
}

mpz_clears (P, t2, t, z, x, y, NULL);
}

void
factor (mpz_t t, struct factors *factors)
{
factor_init (factors);

if (mpz_sgn (t) != 0)
{
factor_using_division (t, factors);

if (mpz_cmp_ui (t, 1) != 0)
{
if (flag_verbose > 0)
{
printf ("[is number prime?] ");
}
if (mp_prime_p (t))
factor_insert (factors, t);
else
factor_using_pollard_rho (t, 1, factors);
}
}
}

int
main (int argc, char *argv[])
{
mpz_t t;
int i, j, k;
struct factors factors;

while (argc > 1)
{
if (!strcmp (argv[1], "-v"))
flag_verbose = 1;
else if (!strcmp (argv[1], "-w"))
flag_prove_primality = 0;
else
break;

argv++;
argc--;
}

mpz_init (t);
if (argc > 1)
{
for (i = 1; i < argc; i++)
{
mpz_set_str (t, argv[i], 0);

gmp_printf ("%Zd:", t);
factor (t, &factors);

for (j = 0; j < factors.nfactors; j++)
for (k = 0; k < factors.e[j]; k++)
gmp_printf (" %Zd", factors.p[j]);

puts ("");
factor_clear (&factors);
}
}
else
{
for (;;)
{
mpz_inp_str (t, stdin, 0);
if (feof (stdin))
break;

gmp_printf ("%Zd:", t);
factor (t, &factors);

for (j = 0; j < factors.nfactors; j++)
for (k = 0; k < factors.e[j]; k++)
gmp_printf (" %Zd", factors.p[j]);

puts ("");
factor_clear (&factors);
}
}

exit (0);
}
``````