def createDeBruijnSequence( n, k ):
wordSize = real_int( k )
symbolCount = real_int( n )
v = [ 0 for _ in range( wordSize ) ]
l = 1
result = [ ]
while True:
if wordSize % l == 0:
result.extend( v[ 0 : l ] )
for i in range( l, wordSize ):
v[ i ] = v[ i - l ]
l = wordSize
while l > 0 and v[ l - 1 ] >= symbolCount - 1:
l -= 1
if l == 0:
break
v[ l - 1 ] += 1
return result
def isMorphic( n, k ):
'''
Returns true if n to the k power ends with n.
'''
digits = getMPFIntegerAsString( real_int( n ) )
sqr_digits = getMPFIntegerAsString( power( n, real_int( k ) ) )
start = len( sqr_digits ) - len( digits )
return 1 if ( sqr_digits[ start : ] == digits ) else 0
def findPalindrome( n, k ):
next = int( real_int( n ) )
for i in range( int( real_int( k ) ) + 1 ):
if isPalindrome( next ):
return [ i, next ]
else:
next = reverseDigits( next ) + next
return [ k, 0 ]
def getBitCount( n ):
result = 0
if isinstance( n, RPNMeasurement ):
value = real_int( n.getValue( ) )
else:
value = real_int( n )
while ( value ):
value &= value - 1
result += 1
return result
def getNthPrimeRange( arg1, arg2 ):
n = int( real_int( arg1 ) )
count = int( real_int( arg2 ) )
if count < 1:
return [ ]
# for primes below 7, we have to do it manually
if n == 1:
if count == 1:
return [ 2 ]
elif count == 2:
return[ 2, 3 ]
elif count == 3:
return [ 2, 3, 5 ]
else:
result = [ 2, 3, 5, 7 ]
count -= 3
p = 7
elif n == 2:
if count == 1:
return [ 3 ]
elif count == 2:
return [ 3, 5 ]
else:
result = [ 3, 5, 7 ]
count -= 2
p = 7
elif n == 3:
if count == 1:
return [ 5 ]
else:
result = [ 5, 7 ]
count -= 1
p = 7
else:
p = getNthPrime( n )
result = [ p ]
found = 1
while found < count:
p = getNextPrimeCandidate( p )
if isPrime( p ):
result.append( p )
found += 1
return result
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 calculateLaborDay( year ):
if isinstance( year, RPNDateTime ):
year = year.year
else:
year = real_int( year )
return calculateNthWeekdayOfMonth( year, 9, 1, 1 )
def calculateThanksgiving( year ):
if isinstance( year, RPNDateTime ):
year = year.year
else:
year = real_int( year )
return calculateNthWeekdayOfMonth( year, November, 4, Thursday )
def calculateNthWeekdayOfMonth( year, month, nth, weekday ):
if real( weekday ) > Sunday or weekday < Monday:
raise ValueError( 'day of week must be 1 - 7 (Monday to Sunday)' )
if isinstance( year, RPNDateTime ):
year = year.year
else:
year = real_int( year )
firstDayOfWeek = arrow.Arrow( real( year ), real( month ), 1 ).isoweekday( )
if nth < 0:
day = ( ( real( weekday ) + 1 ) - firstDayOfWeek ) % 7
while day <= getLastDayOfMonth( year, month ):
day += 7
day += nth * 7
else:
day = ( real( weekday ) - firstDayOfWeek + 1 ) + nth * 7
if weekday >= firstDayOfWeek:
day -= 7
return RPNDateTime( year, month, day, dateOnly = True )
def getNthOctagonalTriangularNumber( n ):
sign = power( -1, real( n ) )
return nint( floor( fdiv( fmul( fsub( 7, fprod( [ 2, sqrt( 6 ), sign ] ) ),
power( fadd( sqrt( 3 ), sqrt( 2 ) ),
fsub( fmul( 4, real_int( n ) ), 2 ) ) ),
96 ) ) )
def getNthIsolatedPrime( arg ):
global isolatedPrimes
global updateDicts
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:
if isolatedPrimes == { }:
isolatedPrimes = loadIsolatedPrimes( g.dataPath )
currentIndex = max( key for key in isolatedPrimes if key <= n )
p = isolatedPrimes[ currentIndex ]
else:
currentIndex = 2
p = 23
while n > currentIndex:
p = getNextPrime( p )
if not isPrime( p - 2 ) and not isPrime( p + 2 ):
currentIndex += 1
if updateDicts:
isolatedPrimes[ n ] = p
return p
def getNthNonagonalOctagonalNumber( n ):
sqrt6 = sqrt( 6 )
sqrt7 = sqrt( 7 )
return nint( floor( fdiv( fmul( fsub( fmul( 11, sqrt7 ), fmul( 9, sqrt6 ) ),
power( fadd( sqrt6, sqrt7 ), fsub( fmul( 8, real_int( n ) ), 5 ) ) ),
672 ) ) )
def combineDigits( n ):
result = 0
for i in n:
result = addDigits( result, real_int( i ) )
return result
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 calculateMemorialDay( year ):
if isinstance( year, RPNDateTime ):
year = year.year
else:
year = real_int( year )
return calculateNthWeekdayOfMonth( year, May, -1, Monday )
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 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 getNSphereRadius( n, k ):
if real_int( k ) < 3:
raise ValueError( 'the number of dimensions must be at least 3' )
if not isinstance( n, RPNMeasurement ):
return RPNMeasurement( n, 'meter' )
dimensions = n.getDimensions( )
if dimensions == { 'length' : 1 }:
return n
elif dimensions == { 'length' : int( k - 1 ) }:
m2 = n.convertValue( RPNMeasurement( 1, [ { 'meter' : int( k - 1 ) } ] ) )
result = root( fdiv( fmul( m2, gamma( fdiv( k, 2 ) ) ),
fmul( 2, power( pi, fdiv( k, 2 ) ) ) ), fsub( k, 1 ) )
return RPNMeasurement( result, [ { 'meter' : 1 } ] )
elif dimensions == { 'length' : int( k ) }:
m3 = n.convertValue( RPNMeasurement( 1, [ { 'meter' : int( k ) } ] ) )
result = root( fmul( fdiv( gamma( fadd( fdiv( k, 2 ), 1 ) ),
power( pi, fdiv( k, 2 ) ) ),
m3 ), k )
return RPNMeasurement( result, [ { 'meter' : 1 } ] )
else:
raise ValueError( 'incompatible measurement type for computing the radius: ' +
str( dimensions ) )
def findNthPolygonalNumber( n, k ):
if real_int( k ) < 3:
raise ValueError( 'the number of sides of the polygon cannot be less than 3,' )
return nint( fdiv( fsum( [ sqrt( fsum( [ power( k, 2 ), fprod( [ 8, k, real( n ) ] ),
fneg( fmul( 8, k ) ), fneg( fmul( 16, n ) ), 16 ] ) ),
k, -4 ] ), fmul( 2, fsub( k, 2 ) ) ) )
def calculatePresidentsDay( year ):
if isinstance( year, RPNDateTime ):
year = year.year
else:
year = real_int( year )
return calculateNthWeekdayOfMonth( year, February, 3, Monday )
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 getCompositions( n, k ):
value = int( real_int( n ) )
count = int( real_int( k ) )
if count < 1:
raise ValueError( "'compositions' expects a size argument greater than 0'" )
if count == 1:
return [ [ value ] ]
else:
result = [ ]
for i in range( 1, int( ( value - count ) + 2 ) ):
result.extend( [ [ nint( i ) ] + comp for comp in getCompositions( n - i, count - 1 ) ] )
return result
def findQuintupletPrimes( arg ):
global quintPrimes
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 ]
if quintPrimes == { }:
quintPrimes = loadQuintupletPrimes( g.dataPath )
currentIndex = max( key for key in quintPrimes if quintPrimes[ key ] <= n )
p = quintPrimes[ currentIndex ]
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 calculateNthWeekdayOfYear( year, nth, weekday ):
if isinstance( year, RPNDateTime ):
year = year.year
else:
year = real_int( year )
if real( nth ) > 0:
firstDay = RPNDateTime( year, 1, 1 )
firstWeekDay = real( weekday ) - firstDay.isoweekday( ) + 1
if firstWeekDay < 1:
firstWeekDay += 7
result = RPNDateTime( year, 1, firstWeekDay ).add( RPNMeasurement( nth - 1, 'week' ) )
result.setDateOnly( )
return result
elif nth < 0:
lastDay = RPNDateTime( year, 12, 31 )
lastWeekDay = real( weekday ) - lastDay.isoweekday( )
if lastWeekDay > 0:
lastWeekDay -= 7
lastWeekDay += 31
result = RPNDateTime( year, 12, lastWeekDay, dateOnly = True ).add( RPNMeasurement( ( nth + 1 ), 'week' ) )
result.setDateOnly( )
return result
def isUnusual( n ):
if real_int( n ) < 2:
return 0
factors = getECMFactors( n ) if g.ecm else getFactors( n )
return 1 if max( [ i[ 0 ] for i in factors ] ) > sqrt( n ) else 0
def isSquareFree( n ):
if real_int( n ) == 0:
return 0
factors = getECMFactors( n ) if g.ecm else getFactors( n )
return 1 if max( [ i[ 1 ] for i in factors ] ) == 1 else 0
def getNthCalkinWilf( n ):
if real_int( n ) < 0:
raise ValueError( 'non-negative, real integer expected' )
if n == 0:
return 0
return fdiv( getNthStern( n ), getNthStern( fadd( n, 1 ) ) )
def findCenteredPolygonalNumber( n, k ):
if real_int( k ) < 3:
raise ValueError( 'the number of sides of the polygon cannot be less than 3,' )
s = fdiv( k, 2 )
return nint( fdiv( fadd( sqrt( s ),
sqrt( fsum( [ fmul( 4, real( n ) ), s, -4 ] ) ) ), fmul( 2, sqrt( s ) ) ) )
def calculateElectionDay( year ):
if isinstance( year, RPNDateTime ):
year = year.year
else:
year = real_int( year )
result = calculateNthWeekdayOfMonth( year, November, 1, Monday)
return result.replace( day = result.day + 1 )