Skip to content

Instantly share code, notes, and snippets.

@Hermann-SW

Hermann-SW/factorize.c

Last active May 17, 2021
Embed
What would you like to do?
gmp-6.2.1/demos/factorize.c modified to alway use Pollard Rho, with new command line arguments "-i" and "-a"
/* 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, long a, struct factors *factors, long *ii)
{
mpz_t x, z, y, P;
mpz_t t, t2, ta;
unsigned long long k, l, i, c=0;
if (flag_verbose > 0)
{
printf ("[pollard-rho (%l)] ", a);
}
mpz_inits (t, t2, NULL);
if (ii==NULL)
{
mpz_init_set_si (y, 2);
mpz_init_set_si (x, 2);
mpz_init_set_si (z, 2);
}
else
{
mpz_init_set_si (y, *ii);
mpz_init_set_si (x, *ii);
mpz_init_set_si (z, *ii);
}
mpz_init_set_ui (P, 1);
k = 1;
l = 32;
mpz_init_set_si (ta, a);
while (mpz_cmp_ui (n, 1) != 0)
{
for (;;)
{
do
{
++c;
mpz_mul (t, x, x);
mpz_mod (x, t, n);
mpz_add (x, x, ta);
mpz_mul (t, z, z);
mpz_mod (z, t, n);
mpz_add (z, z, ta);
mpz_mul (t, z, z);
mpz_mod (z, t, n);
mpz_add (z, z, ta);
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);
k = l;
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);
gmp_printf (" %Zd * ... [%ld]", t, c);
exit(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, ii);
}
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 (ta, 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, NULL);
}
}
}
int
main (int argc, char *argv[])
{
mpz_t t;
int i, j, k;
struct factors factors;
int a = 1;
long int ii=2;
while (argc > 1)
{
if (!strcmp (argv[1], "-v"))
flag_verbose = 1;
else if (!strcmp (argv[1], "-w"))
flag_prove_primality = 0;
else if (!strcmp (argv[1], "-a"))
{
argv++;
argc--;
a = atoi(argv[1]);
}
else if (!strcmp (argv[1], "-i"))
{
argv++;
argc--;
ii = atoi(argv[1]);
}
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);
factor_init (&factors);
factor_using_pollard_rho (t, a, &factors, &ii);
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);
}
@Hermann-SW

This comment has been minimized.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment