def getNthSquareTriangularNumber( n ): neededPrecision = int( real_int( n ) * 3.5 ) # determined by experimentation if mp.dps < neededPrecision: setAccuracy( neededPrecision ) sqrt2 = sqrt( 2 ) return nint( power( fdiv( fsub( power( fadd( 1, sqrt2 ), fmul( 2, n ) ), power( fsub( 1, sqrt2 ), fmul( 2, n ) ) ), fmul( 4, sqrt2 ) ), 2 ) )
def parseInputValue( term, inputRadix ): if isinstance( term, mpf ): return term innerChars = term[ 1 : -1 ] # this helps us parse dates if '/' in innerChars: term = term.replace( '/', '-' ) innerChars = term[ 1 : -1 ] # 'e' implies scientific notation, which isn't a date regardless if ( 'e' not in innerChars ): # 'd' means a dice expression, '[' means a build_number expression, so don't treat it as a date if ( ( '-' in innerChars ) or ( ':' in innerChars ) ) and ( 'd' not in term ) and ( '[' not in term ): # try: datetime = arrow.get( term ) datetime = RPNDateTime( datetime.year, datetime.month, datetime.day, datetime.hour, datetime.minute, datetime.second, datetime.microsecond ) # except: # raise ValueError( 'error parsing datetime' ) return datetime if term == '0': return mpmathify( 0 ) # ignore commas term = ''.join( [ i for i in term if i not in ',' ] ) if term[ 0 ] == '\\': term = term[ 1 : ] ignoreSpecial = True else: ignoreSpecial = False if '.' in term: if inputRadix == 10: newPrecision = len( term ) + 1 if mp.dps < newPrecision: setAccuracy( newPrecision ) return mpmathify( term ) decimal = term.find( '.' ) else: decimal = len( term ) negative = term[ 0 ] == '-' if negative: start = 1 else: if term[ 0 ] == '+': start = 1 else: start = 0 integer = term[ start : decimal ] mantissa = term[ decimal + 1 : ] # check for hex, then binary, then octal, otherwise a plain old decimal integer if not ignoreSpecial and mantissa == '': if integer[ 0 ] == '0': if len( integer ) == 1: return mpmathify( 0 ) if integer[ 1 ] in 'Xx': # set the precision big enough to handle this value newPrecision = math.ceil( ( math.log10( 16 ) * ( len( integer ) - 2 ) ) ) + 1 if mp.dps < newPrecision: setAccuracy( newPrecision ) return mpmathify( int( integer[ 2 : ], 16 ) ) elif integer[ -1 ] in 'bB': # set the precision big enough to handle this value newPrecision = math.ceil( math.log10( 2 ) * ( len( integer ) - 1 ) ) + 1 if mp.dps < newPrecision: setAccuracy( newPrecision ) integer = integer[ : -1 ] return mpmathify( int( integer, 2 ) * ( -1 if negative else 1 ) ) else: integer = integer[ 1 : ] return mpmathify( int( integer, 8 ) ) if integer[ 0 ] == '1' and integer[ -1 ] in 'bB': # set the precision big enough to handle this value newPrecision = math.ceil( math.log10( 2 ) * ( len( integer ) - 1 ) ) + 1 if mp.dps < newPrecision: setAccuracy( newPrecision ) integer = integer[ : -1 ] return mpmathify( int( integer, 2 ) * ( -1 if negative else 1 ) ) elif inputRadix == 10: newPrecision = len( integer ) + 1 if mp.dps < newPrecision: setAccuracy( newPrecision ) return fneg( integer ) if negative else mpmathify( integer ) # finally, we have a non-radix 10 number to parse result = convertToBase10( integer, mantissa, inputRadix ) return fneg( result ) if negative else mpmathify( result )
def getFactors( n ): ''' A factorization of *Nptr into prime and q-prime factors is first obtained. Selfridge's primality test is then applied to any q-prime factors; the test is applied repeatedly until either a q-prime is found to be composite or likely to be composite (in which case the initial factorization is doubtful and an extra base should be used in Miller's test) or we run out of q-primes, in which case every q-prime factor of *Nptr is certified as prime. Returns a list of tuples where each tuple is a prime factor and an exponent. ''' verbose = g.verbose if real( n ) < -1: return [ ( -1, 1 ) ] + getFactors( fneg( n ) ) elif n == -1: return [ ( -1, 1 ) ] elif n == 0: return [ ( 0, 1 ) ] elif n == 1: return [ ( 1, 1 ) ] target = int( n ) dps = ceil( log( n ) ) if dps > mp.dps: setAccuracy( dps ) if target > g.minValueToCache: if g.factorCache is None: loadFactorCache( ) if target in g.factorCache: if verbose: print( 'cache hit:', target ) return g.factorCache[ target ] smallFactors, largeFactors, qPrimes = getPrimeFactors( int( n ), verbose ) if qPrimes: if verbose: print( 'testing q-primes for primality' ) print( '--' ) i = 0 for qPrime in qPrimes: t = doSelfridgeTest( qPrime[ 0 ], verbose ) if not t: print( 'do FACTOR() again with an extra base' ) return 0 if verbose: print( 'all q-primes are primes:', n, 'has the following factorization:' ) print( ) for i in smallFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) for i in largeFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) else: if verbose: print( 'NO Q-PRIMES:' ) print( ) print( n, 'has the following factorization:' ) for i in smallFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) for i in largeFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) result = [ ] result.extend( smallFactors ) result.extend( largeFactors ) if g.factorCache is not None: product = int( fprod( [ power( i[ 0 ], i[ 1 ] ) for i in largeFactors ] ) ) if product not in g.factorCache: g.factorCache[ product ] = largeFactors g.factorCacheIsDirty = True if n > g.minValueToCache and n not in g.factorCache: g.factorCache[ n ] = result g.factorCacheIsDirty = True return result
def getFactors( n ): verbose = g.verbose if real( n ) < -1: return [ ( -1, 1 ) ] + getFactors( fneg( n ) ) elif n == -1: return [ ( -1, 1 ) ] elif n == 0: return [ ( 0, 1 ) ] elif n == 1: return [ ( 1, 1 ) ] target = int( n ) dps = ceil( log( n ) ) if dps > mp.dps: setAccuracy( dps ) if target > g.minValueToCache: if g.factorCache is None: loadFactorCache( ) if target in g.factorCache: if verbose: print( 'cache hit:', target ) return g.factorCache[ target ] smallFactors, largeFactors, qPrimes = getPrimeFactors( int( n ), verbose ) if qPrimes: if verbose: print( 'testing q-primes for primality' ) print( '--' ) i = 0 for qPrime in qPrimes: t = doSelfridgeTest( qPrime[ 0 ], verbose ) if not t: print( 'do FACTOR() again with an extra base' ) return 0 if verbose: print( 'all q-primes are primes:', n, 'has the following factorization:' ) print( ) for i in smallFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) for i in largeFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) else: if verbose: print( 'NO Q-PRIMES:' ) print( ) print( n, 'has the following factorization:' ) for i in smallFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) for i in largeFactors: print( 'prime factor:', i[ 0 ], 'exponent:', i[ 1 ] ) result = [ ] result.extend( smallFactors ) result.extend( largeFactors ) if g.factorCache is not None: product = int( fprod( [ power( i[ 0 ], i[ 1 ] ) for i in largeFactors ] ) ) if product not in g.factorCache: g.factorCache[ product ] = largeFactors g.factorCacheIsDirty = True if n > g.minValueToCache and n not in g.factorCache: g.factorCache[ n ] = result g.factorCacheIsDirty = True return result