def getNthCousinPrime( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 3
elif n >= 100:
openPrimeCache( 'cousin_primes' )
maxIndex = g.cursors[ 'cousin_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
currentIndex, p = g.cursors[ 'cousin_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
else:
currentIndex = 2
p = 7
while n > currentIndex:
p = getNextPrime( p )
if isPrime( p + 4 ):
currentIndex += 1
return p
def getNthSexyPrime( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 5
elif n >= 100:
openPrimeCache( 'sexy_primes' )
maxIndex = g.cursors[ 'sexy_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
startingPlace, p = g.cursors[ 'sexy_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
else:
startingPlace = 2
p = 7
while n > startingPlace:
p = getNextPrime( p, getNextSexyPrimeCandidate )
if isPrime( p + 6 ):
n -= 1
return p
def getNthQuadrupletPrime( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 5
elif n == 2:
return 11
if n >= 10:
openPrimeCache( 'quad_primes' )
maxIndex = g.cursors[ 'quad_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
startingPlace, p = g.cursors[ 'quad_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
else:
startingPlace = 2
p = 11
# after 5, the first of a prime quadruplet must be a number of the form 30n + 11
while n > startingPlace:
p += 30
if isPrime( p ) and isPrime( p + 2 ) and isPrime( p + 6 ) and isPrime( p + 8 ):
n -= 1
return p
def getNthIsolatedPrime( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 2
elif n == 2:
return 23
elif n >= 1000:
openPrimeCache( 'isolated_primes' )
currentIndex, p = g.cursors[ 'isolated_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
else:
currentIndex = 2
p = 23
while n > currentIndex:
p = getNextPrime( p )
if not isPrime( p - 2 ) and not isPrime( p + 2 ):
currentIndex += 1
return p
def getNthSextupletPrime( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 7
elif n >= 10:
openPrimeCache( 'sext_primes' )
maxIndex = g.cursors[ 'sext_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
startingPlace, p = g.cursors[ 'sext_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
else:
startingPlace = 1
p = 7
# all sets of prime sextuplets must start with 30x+7
while n > startingPlace:
p += 30
if isPrime( p ) and isPrime( p + 4 ) and isPrime( p + 6 ) and \
isPrime( p + 10 ) and isPrime( p + 12 ) + isPrime( 16 ):
n -= 1
return p
def findQuintupletPrimes( arg ):
n = int( real_int( arg ) )
if n < 5:
return 1, [ 5, 7, 11, 13, 17 ]
elif n < 7:
return 2, [ 7, 11, 13, 17, 19 ]
openPrimeCache( 'quint_primes' )
currentIndex, p = g.cursors[ 'quint_primes' ].execute(
'''SELECT id, max( value ) FROM cache WHERE value <= ?''', ( n, ) ).fetchone( )
while True:
p += 30
f = p % 10
if ( ( f == 1 ) and isPrime( p + 2 ) and isPrime( p + 6 ) and isPrime( p + 8 ) and isPrime( p + 12 ) ) or \
( ( f == 7 ) and isPrime( p + 4 ) and isPrime( p + 6 ) and isPrime( p + 10 ) and isPrime( p + 12 ) ):
currentIndex += 1
if p > n:
if f == 1:
return currentIndex, [ p, fadd( p, 2 ), fadd( p, 6 ), fadd( p, 8 ), fadd( p, 12 ) ]
elif f == 7:
return currentIndex, [ p, fadd( p, 4 ), fadd( p, 6 ), fadd( p, 10 ), fadd( p, 12 ) ]
def getNthTripletPrimeList( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return [ 5, 7, 11 ]
elif n == 2:
return [ 7, 11, 13 ]
if n >= 100:
openPrimeCache( 'triplet_primes' )
maxIndex = g.cursors[ 'triplet_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
currentIndex, p = g.cursors[ 'triplet_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
else:
currentIndex = 3
p = 11
f = p % 10
pPlus2 = False
while n > currentIndex:
if f == 1:
p += 2
f = 3
elif f == 3:
p += 4
f = 7
else:
p += 4
f = 1
if isPrime( p ) and isPrime( p + 6 ):
if isPrime( p + 2 ):
pPlus2 = True
currentIndex += 1
elif isPrime( p + 4 ):
pPlus2 = False
currentIndex += 1
return [ p, p + 2 if pPlus2 else p + 4, p + 6 ]
def getNthDoubleBalancedPrime( arg, first = False ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 18713
openPrimeCache( 'double_balanced_primes' )
maxIndex = g.cursors[ 'double_balanced_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
primes = [ ]
currentIndex, p = g.cursors[ 'double_balanced_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
primes = [ p ]
for i in range( 0, 4 ):
p = getNextPrime( p )
primes.append( p )
while n > currentIndex:
p = getNextPrime( p )
primes.append( p )
del primes[ 0 ]
if ( ( primes[ 2 ] - primes[ 1 ] ) == ( primes[ 3 ] - primes[ 2 ] ) and
( primes[ 1 ] - primes[ 0 ] ) == ( primes[ 4 ] - primes[ 3 ] ) ):
currentIndex += 1
result = primes[ 0 ] if first else primes[ 2 ]
return result
def getNthBalancedPrime( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 3
elif n == 2:
return 5
elif n >= 100:
openPrimeCache( 'balanced_primes' )
maxIndex = g.cursors[ 'balanced_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
currentIndex, p = g.cursors[ 'balanced_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
prevPrime = 0
secondPrevPrime = 0
else:
currentIndex = 2
p = 11
prevPrime = 7
secondPrevPrime = 5
while n > currentIndex:
p = getNextPrime( p )
if ( prevPrime - secondPrevPrime ) == ( p - prevPrime ):
currentIndex += 1
if n > currentIndex:
secondPrevPrime = prevPrime
prevPrime = p
return secondPrevPrime
def findQuadrupletPrimes( arg ):
n = int( real_int( arg ) )
if n < 5:
return 1, [ 5, 7, 11, 13 ]
elif n < 11:
return 2, [ 11, 13, 17, 19 ]
openPrimeCache( 'quad_primes' )
currentIndex, p = g.cursors[ 'quad_primes' ].execute(
'''SELECT id, max( value ) FROM cache WHERE value <= ?''', ( n, ) ).fetchone( )
while True:
p += 30
if isPrime( p ) and isPrime( p + 2 ) and isPrime( p + 6 ) and isPrime( p + 8 ):
currentIndex += 1
if p > n:
return currentIndex, [ p, p + 2, p + 6, p + 8 ]
def getNthSexyQuadruplet( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 5
elif n < 100:
startingPlace = 2
p = 11
elif n >= 100:
openPrimeCache( 'sexy_quadruplets' )
maxIndex = g.cursors[ 'sexy_quadruplets' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
startingPlace, p = g.cursors[ 'sexy_quadruplets' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
ten = True
while n > startingPlace:
if ten:
p += 10
ten = False
else:
p += 20
ten = True
if isPrime( p ) and isPrime( p + 6 ) and isPrime( p + 12 ) and isPrime( p + 18 ):
n -= 1
return p
def getNthQuintupletPrime( arg ):
n = int( real_int( arg ) )
if n < 1:
raise ValueError( 'index must be > 0' )
elif n == 1:
return 5
elif n == 2:
return 7
if n >= 10:
openPrimeCache( 'quint_primes' )
maxIndex = g.cursors[ 'quint_primes' ].execute(
'''SELECT MAX( id ) FROM cache''' ).fetchone( )[ 0 ]
if n > maxIndex:
sys.stderr.write( '{:,} is above the max cached index of {:,}. This could take some time...\n'.
format( n, maxIndex ) )
currentIndex, p = g.cursors[ 'quint_primes' ].execute(
'''SELECT MAX( id ), value FROM cache WHERE id <= ?''', ( int( n ), ) ).fetchone( )
else:
currentIndex = 3
p = 11
# after 5, the first of a prime quintruplet must be a number of the form 30n + 11
while n > currentIndex:
p = getNextPrime( p, getNextQuintupletPrimeCandidate )
f = ( p - 10 ) % 30
if ( ( f == 1 ) and isPrime( p + 2 ) and isPrime( p + 6 ) and isPrime( p + 8 ) and isPrime( p + 12 ) ) or \
( ( f == 7 ) and isPrime( p + 4 ) and isPrime( p + 6 ) and isPrime( p + 10 ) and isPrime( p + 12 ) ):
currentIndex += 1
return p
def findPrime( arg ):
target = int( arg )
if target < 3:
return 1, 2
elif target == 3:
return 2, 3
elif target <= 5:
return 3, 5
elif target <= 7:
return 4, 7
elif target < 541: # 100th prime
currentIndex = 4
p = 7
elif target < 15485863: # 1,000,000th prime
openPrimeCache( 'small_primes' )
currentIndex, p = g.cursors[ 'small_primes' ].execute(
'''SELECT id, max( value ) FROM cache WHERE value <= ?''', ( target, ) ).fetchone( )
elif target < 22801763489: # 1,000,000,000th prime
openPrimeCache( 'large_primes' )
currentIndex, p = g.cursors[ 'large_primes' ].execute(
'''SELECT id, max( value ) FROM cache WHERE value <= ?''', ( target, ) ).fetchone( )
else:
openPrimeCache( 'huge_primes' )
currentIndex, p = g.cursors[ 'huge_primes' ].execute(
'''SELECT id, max( value ) FROM cache WHERE value <= ?''', ( target, ) ).fetchone( )
while True:
p = getNextPrime( p )
currentIndex += 1
if p >= target:
return currentIndex, p
def getMaxPrime( name ):
openPrimeCache( name )
return g.cursors[ name ].execute( '''SELECT max( id ), value FROM cache''' ).fetchone( )
def countCache( name ):
openPrimeCache( name )
return g.cursors[ name ].execute( '''SELECT count( id ) FROM cache''' ).fetchone( )[ 0 ]
