def testGenerator(self):
g = prime.generator()
self.assertEqual(2, g.next())
self.assertEqual(3, g.next())
## g2 = prime.generator(lambda x: x % 5 == 4) # old fashioned
import itertools
g2 = itertools.ifilter(lambda x: x % 5 == 4, prime.generator())
self.assertEqual(19, g2.next())
self.assertEqual(29, g2.next())
def trial_division_ternary(n):
"""
Test the squarefreeness of n.
The return value is one of the True or False, not None.
The method is a kind of trial division.
"""
result = trivial_test_ternary(n)
if result is not None:
return result
for p in prime.generator():
if not (n % (p*p)):
# found a square factor
return False
elif not (n % p):
# found a non-square factor
n //= p
result = trivial_test_ternary(n)
if result is not None:
return result
if p*p*p > n:
break
# At the end of the loop:
# n doesn't have any factor less than its cubic root.
# n is not a prime nor a perfect square number.
# The factor must be two primes p and q such that p < sqrt(n) < q.
return True
def trial_division(n):
"""
Test whether n is squarefree or not.
The method is a kind of trial division.
"""
try:
return trivial_test(n)
except Undetermined:
pass
for p in prime.generator():
if not (n % (p*p)):
# found a square factor
return False
elif not (n % p):
# found a non-square factor
n //= p
try:
return trivial_test(n)
except Undetermined:
pass
if p*p*p > n:
break
# At the end of the loop:
# n doesn't have any factor less than its cubic root.
# n is not a prime nor a perfect square number.
# The factor must be two primes p and q such that p < sqrt(n) < q.
return True
def trial_division(n):
"""
Test whether n is squarefree or not.
The method is a kind of trial division.
"""
try:
return trivial_test(n)
except Undetermined:
pass
for p in prime.generator():
if not (n % (p*p)):
# found a square factor
return False
elif not (n % p):
# found a non-square factor
n //= p
try:
return trivial_test(n)
except Undetermined:
pass
if p*p*p > n:
break
# At the end of the loop:
# n doesn't have any factor less than its cubic root.
# n is not a prime nor a perfect square number.
# The factor must be two primes p and q such that p < sqrt(n) < q.
return True
def trial_division_ternary(n):
"""
Test the squarefreeness of n.
The return value is one of the True or False, not None.
The method is a kind of trial division.
"""
result = trivial_test_ternary(n)
if result is not None:
return result
for p in prime.generator():
if not (n % (p*p)):
# found a square factor
return False
elif not (n % p):
# found a non-square factor
n //= p
result = trivial_test_ternary(n)
if result is not None:
return result
if p*p*p > n:
break
# At the end of the loop:
# n doesn't have any factor less than its cubic root.
# n is not a prime nor a perfect square number.
# The factor must be two primes p and q such that p < sqrt(n) < q.
return True
def padic_factorization(f):
"""
padic_factorization(f) -> p, factors
Return a prime p and a p-adic factorization of given integer
coefficient squarefree polynomial f. The result factors have
integer coefficients, injected from F_p to its minimum absolute
representation. The prime is chosen to be 1) f is still squarefree
mod p, 2) the number of factors is not greater than with the
successive prime.
"""
num_factors = f.degree()
stock = None
for p in prime.generator():
fmodp = uniutil.polynomial(f.terms(),
finitefield.FinitePrimeField.getInstance(p))
if f.degree() > fmodp.degree():
continue
g = fmodp.getRing().gcd(fmodp, fmodp.differentiate())
if g.degree() == 0:
fp_factors = fmodp.factor()
if (not stock) or num_factors > len(fp_factors):
stock = (p, fp_factors)
if len(fp_factors) == 1:
return stock
num_factors = len(fp_factors)
else:
break
p = stock[0]
fp_factors = []
for (fp_factor, m) in stock[1]:
assert m == 1 # since squarefree
fp_factors.append(minimum_absolute_injection(fp_factor))
return (p, fp_factors)
def pmom(n, **options):
"""
This function tries to find a non-trivial factor of n using
Algorithm 8.8.2 (p-1 first stage) of Cohen's book.
In case of N = pow(2,i), this program will not terminate.
"""
# verbosity
verbose = options.get('verbose', False)
if not verbose:
_silence()
# initialize
x = y = 2
primes = []
if 'B' in options:
B = options['B']
else:
B = 10000
for q in prime.generator():
primes.append(q)
if q > B:
if gcd.gcd(x - 1, n) == 1:
if not verbose:
_verbose()
return 1
x = y
break
q1 = q
l = B // q
while q1 <= l:
q1 *= q
x = pow(x, q1, n)
if len(primes) >= 20:
if gcd.gcd(x - 1, n) == 1:
primes, y = [], x
else:
x = y
break
for q in primes:
q1 = q
while q1 <= B:
x = pow(x, q, n)
g = gcd.gcd(x - 1, n)
if g != 1:
if not verbose:
_verbose()
if g == n:
return 1
return g
q1 *= q
def zeta_real(s):
"""
zeta function for a real positive value s.
zeta(s) = \sum n^{-s} = \prod (1 - p^{-s})^{-1}
"""
zeta_s = 1
for p in prime.generator():
euler_factor = 1 - 1 / p**s
if euler_factor == 1:
break
zeta_s /= euler_factor
return zeta_s
def pmom(n, **options):
"""
This function tries to find a non-trivial factor of n using
Algorithm 8.8.2 (p-1 first stage) of Cohen's book.
In case of N = pow(2,i), this program will not terminate.
"""
# verbosity
verbose = options.get('verbose', False)
if not verbose:
_silence()
# initialize
x , B = 2 , 10000001
y = x
primes = []
for q in prime.generator():
primes.append(q)
if q > B:
if gcd.gcd(x-1, n) == 1:
if not verbose:
_verbose()
return 1
x = y
break
q1 = q
l = B//q
while q1 <= l:
q1 *= q
x = pow(x, q1, n)
if len(primes) >= 20:
if gcd.gcd(x-1, n) == 1:
primes, y = [], x
else:
x = y
break
for q in primes:
q1 = q
while q1 <= B:
x = pow(x, q, n)
g = gcd.gcd(x-1, n)
if g != 1:
if not verbose:
_verbose()
if g == n:
return 1
return g
q1 *= q
def _parse_seq(self, options):
"""
Parse 'options' to define trial sequaence.
"""
if 'start' in options and 'stop' in options:
if 'step' in options:
trials = bigrange.range(options['start'], options['stop'], options['step'])
else:
trials = bigrange.range(options['start'], options['stop'])
elif 'iterator' in options:
trials = options['iterator']
elif 'eratosthenes' in options:
trials = prime.generator_eratosthenes(options['eratosthenes'])
elif options['n'] < 1000000:
trials = prime.generator_eratosthenes(arith1.floorsqrt(options['n']))
else:
trials = prime.generator()
return trials
def _parse_seq(self, options):
"""
Parse 'options' to define trial sequaence.
"""
if 'start' in options and 'stop' in options:
if 'step' in options:
trials = bigrange.range(options['start'], options['stop'],
options['step'])
else:
trials = bigrange.range(options['start'], options['stop'])
elif 'iterator' in options:
trials = options['iterator']
elif 'eratosthenes' in options:
trials = prime.generator_eratosthenes(options['eratosthenes'])
elif options['n'] < 1000000:
trials = prime.generator_eratosthenes(
arith1.floorsqrt(options['n']))
else:
trials = prime.generator()
return trials
def trialDivision(n, **options):
"""
Return a factor of given integer by trial division.
options can be either:
1) 'start' and 'stop' as range parameters.
2) 'iterator' as an iterator of primes.
If both options are not given, prime factor is searched from 2
to the square root of the given integer.
"""
# verbosity
verbose = options.get('verbose', False)
if not verbose:
_silence()
if 'start' in options and 'stop' in options:
if 'step' in options:
trials = list(
range(options['start'], options['stop'], options['step']))
else:
trials = list(range(options['start'], options['stop']))
elif 'iterator' in options:
trials = options['iterator']
elif n < 1000000:
trials = prime.generator_eratosthenes(arith1.floorsqrt(n))
else:
trials = prime.generator()
limit = arith1.floorsqrt(n)
for p in trials:
if limit < p:
break
if 0 == n % p:
if not verbose:
_verbose()
return p
if not verbose:
_verbose()
return 1
def trialDivision(n, **options):
"""
Return a factor of given integer by trial division.
options can be either:
1) 'start' and 'stop' as range parameters.
2) 'iterator' as an iterator of primes.
If both options are not given, prime factor is searched from 2
to the square root of the given integer.
"""
# verbosity
verbose = options.get('verbose', False)
if not verbose:
_silence()
if 'start' in options and 'stop' in options:
if 'step' in options:
trials = range(options['start'], options['stop'], options['step'])
else:
trials = range(options['start'], options['stop'])
elif 'iterator' in options:
trials = options['iterator']
elif n < 1000000:
trials = prime.generator_eratosthenes(arith1.floorsqrt(n))
else:
trials = prime.generator()
for p in trials:
if not (n % p):
if not verbose:
_verbose()
return p
if p ** 2 > n:
break
if not verbose:
_verbose()
return 1
def padic_factorization(f):
"""
padic_factorization(f) -> p, factors
Return a prime p and a p-adic factorization of given integer
coefficient squarefree polynomial f. The result factors have
integer coefficients, injected from F_p to its minimum absolute
representation. The prime is chosen to be 1) f is still squarefree
mod p, 2) the number of factors is not greater than with the
successive prime.
"""
num_factors = f.degree()
stock = None
for p in prime.generator():
fmodp = uniutil.polynomial(
f.terms(),
finitefield.FinitePrimeField.getInstance(p))
if f.degree() > fmodp.degree():
continue
g = fmodp.getRing().gcd(fmodp,
fmodp.differentiate())
if g.degree() == 0:
fp_factors = fmodp.factor()
if not stock or num_factors > len(fp_factors):
stock = (p, fp_factors)
if len(fp_factors) == 1:
return stock
num_factors = len(fp_factors)
else:
break
p = stock[0]
fp_factors = []
for (fp_factor, m) in stock[1]:
assert m == 1 # since squarefree
fp_factors.append(minimum_absolute_injection(fp_factor))
return (p, fp_factors)
if i in primes:
all_subsets |= primes[i]
r = frozenset(all_subsets)
for i in all_subsets:
primes[i] = r
for case_no in xrange(0, input()):
print "Case #%s:" % (case_no + 1,),
A, B, P = map(long, raw_input().split())
B += 1
sz = B-A
prime_numbers = []
for p in prime.generator():
if p > sz:
break
if p >=P: prime_numbers.append( p )
arr = defaultdict(list)
for p in prime_numbers:
s = (A / p) * p
if s < A: s += p
while s < B:
arr[s].append( p )
s += p
primes = {}
g = 0
n = A
while n < B:
