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 getKSphereRadius(n, k): if 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 if dimensions == {'length': int(k - 1)}: area = n.convertValue(RPNMeasurement(1, [{'meter': int(k - 1)}])) result = root( fdiv(fmul(area, gamma(fdiv(k, 2))), fmul(2, power(pi, fdiv(k, 2)))), fsub(k, 1)) return RPNMeasurement(result, [{'meter': 1}]) if dimensions == {'length': int(k)}: volume = n.convertValue(RPNMeasurement(1, [{'meter': int(k)}])) result = root( fmul(fdiv(gamma(fadd(fdiv(k, 2), 1)), power(pi, fdiv(k, 2))), volume), k) return RPNMeasurement(result, [{'meter': 1}]) raise ValueError( 'incompatible measurement type for computing the radius: ' + str(dimensions))
def getSuperRootsOperator(n, k): '''Returns all the super-roots of n, not just the nice, positive, real one.''' k = fsub(k, 1) factors = [fmul(i, root(k, k)) for i in unitroots(int(k))] base = root(fdiv(log(n), lambertw(fmul(k, log(n)))), k) return [fmul(i, base) for i in factors]
def getRoot( n, k ): if isinstance( n, RPNMeasurement ): if not isInteger( k ): raise ValueError( 'cannot take a fractional root of a measurement' ) newUnits = RPNUnits( n.getUnits( ) ) for unit, exponent in newUnits.items( ): if fmod( exponent, k ) != 0: if k == 2: name = 'square' elif k == 3: name = 'cube' else: name = getOrdinalName( k ) raise ValueError( 'cannot take the ' + name + ' root of this measurement: ', n.getUnits( ) ) #print measurement RPNMeasurement.getValue( ) ) newUnits[ unit ] /= k value = root( n.getValue( ), k ) return RPNMeasurement( value, newUnits ) return root( n, k )
def getRoot( self, operand ): if ( floor( operand ) != operand ): raise ValueError( 'cannot take a fractional root of a measurement' ) newUnits = RPNUnits( self.units ) for unit, exponent in newUnits.items( ): if fmod( exponent, operand ) != 0: if operand == 2: name = 'square' elif operand == 3: name = 'cube' else: name = getOrdinalName( operand ) baseUnits = self.convertToBaseUnits( ) if ( baseUnits != self ): return baseUnits.getRoot( operand ) else: raise ValueError( 'cannot take the ' + name + ' root of this measurement: ', self.units ) newUnits[ unit ] /= operand value = root( self.value, operand ) return RPNMeasurement( value, newUnits ).normalizeUnits( )
def getNthPadovanNumber( arg ): n = fadd( real( arg ), 4 ) a = root( fsub( fdiv( 27, 2 ), fdiv( fmul( 3, sqrt( 69 ) ), 2 ) ), 3 ) b = root( fdiv( fadd( 9, sqrt( 69 ) ), 2 ), 3 ) c = fadd( 1, fmul( mpc( 0, 1 ), sqrt( 3 ) ) ) d = fsub( 1, fmul( mpc( 0, 1 ), sqrt( 3 ) ) ) e = power( 3, fdiv( 2, 3 ) ) r = fadd( fdiv( a, 3 ), fdiv( b, e ) ) s = fsub( fmul( fdiv( d, -6 ), a ), fdiv( fmul( c, b ), fmul( 2, e ) ) ) t = fsub( fmul( fdiv( c, -6 ), a ), fdiv( fmul( d, b ), fmul( 2, e ) ) ) return nint( re( fsum( [ fdiv( power( r, n ), fadd( fmul( 2, r ), 3 ) ), fdiv( power( s, n ), fadd( fmul( 2, s ), 3 ) ), fdiv( power( t, n ), fadd( fmul( 2, t ), 3 ) ) ] ) ) )
def __init__(self, polyA=None, polyB=None): # Input as list self.polyA = list(polyA or [0])[:] self.polyB = list(polyB or [0])[:] # Remove leading zero coefficients while self.polyA[-1] == 0: self.polyA.pop() self.len_A = len(self.polyA) while self.polyB[-1] == 0: self.polyB.pop() self.len_B = len(self.polyB) # Add 0 to make lengths equal a power of 2 self.C_max_length = int(2**np.ceil( np.log2(len(self.polyA) + len(self.polyB) - 1))) while len(self.polyA) < self.C_max_length: self.polyA.append(0) while len(self.polyB) < self.C_max_length: self.polyB.append(0) # A complex root used for the fourier transform self.root = complex(mpmath.root(x=1, n=self.C_max_length, k=1)) # The product self.product = self.__multiply()
def getRoot(self, operand): if floor(operand) != operand: raise ValueError('cannot take a fractional root of a measurement') newUnits = RPNUnits(self.units) for unit, exponent in newUnits.items(): if fmod(exponent, operand) != 0: if operand == 2: name = 'square' elif operand == 3: name = 'cube' else: # getOrdinalName( operand ) name = str(int(operand)) + 'th' baseUnits = self.convertToPrimitiveUnits() if baseUnits != self: return baseUnits.getRoot(operand) raise ValueError( 'cannot take the ' + name + ' root of this measurement: ', self.units) newUnits[unit] /= operand value = root(self.value, operand) return RPNMeasurement(value, newUnits).normalizeUnits()
def getRoot(n, k): if isinstance(n, RPNMeasurement): return n.getRoot(k) if not isint(k): return power(n, fdiv(1, k)) return root(n, k)
def getRoot( n, k ): if isinstance( n, RPNMeasurement ): return n.getRoot( k ) if not isint( k ): return power( n, fdiv( 1, k ) ) else: return root( n, k )
def __call__(self, y): """ This function should be used by the root finder. If the brentq root finder is used then the derivative does not help. """ r = self.r2 / self.r1 lhs = self.a1 - self.b1 * mp.root(y, 2) rhs = self.a2 * mp.power(y, r - 1) + self.b2 * mp.power(y, 1.5*r - 1) return rhs - lhs
def __call__(self, y): """ This function should be used by the root finder. If the brentq root finder is used then the derivative does not help. """ r = self.r2 / self.r1 lhs = self.a1 - self.b1 * mp.root(y, 2) rhs = self.a2 * mp.power(y, r - 1) + self.b2 * mp.power(y, 1.5 * r - 1) return rhs - lhs
def calculateGeometricMean( args ): if isinstance( args, RPNGenerator ): return calculateGeometricMean( list( args ) ) elif isinstance( args, list ): if isinstance( args[ 0 ], ( list, RPNGenerator ) ): return [ calculateGeometricMean( list( arg ) ) for arg in args ] else: return root( fprod( args ), len( args ) ) else: return args
def main(): mpmath.mp.dps = 10000 T = int(sys.stdin.readline()) for t in range(1, T+1): N, M = map(int, sys.stdin.readline().strip().split()) a = map(mpmath.mpf, sys.stdin.readline().strip().split()) print "Case #%d:" % t print >> sys.stderr, "Case #%d:" % t for _ in range(M): L, R = map(int, sys.stdin.readline().strip().split()) prod = reduce(lambda x, y: x * y, a[L:R+1], 1) # print >> sys.stderr, "prod", prod, "L", L, "R", R print float(mpmath.root(prod, R-L+1))
def solveQuarticPolynomialOperator( _a, _b, _c, _d, _e ): # pylint: disable=invalid-name ''' This function applies the quartic formula to solve a polynomial with coefficients of a, b, c, d, and e. ''' if mp.dps < 50: mp.dps = 50 # maybe it's really an order-3 polynomial if _a == 0: return solveCubicPolynomial( _b, _c, _d, _e ) # degenerate case, just return the two real and two imaginary 4th roots of the # constant term divided by the 4th root of a if _b == 0 and _c == 0 and _d == 0: e = fdiv( _e, _a ) f = root( _a, 4 ) x1 = fdiv( root( fneg( e ), 4 ), f ) x2 = fdiv( fneg( root( fneg( e ), 4 ) ), f ) x3 = fdiv( mpc( 0, root( fneg( e ), 4 ) ), f ) x4 = fdiv( mpc( 0, fneg( root( fneg( e ), 4 ) ) ), f ) return [ x1, x2, x3, x4 ] # otherwise we have a regular quartic to solve b = fdiv( _b, _a ) c = fdiv( _c, _a ) d = fdiv( _d, _a ) e = fdiv( _e, _a ) # we turn the equation into a cubic that we can solve f = fsub( c, fdiv( fmul( 3, power( b, 2 ) ), 8 ) ) g = fsum( [ d, fdiv( power( b, 3 ), 8 ), fneg( fdiv( fmul( b, c ), 2 ) ) ] ) h = fsum( [ e, fneg( fdiv( fmul( 3, power( b, 4 ) ), 256 ) ), fmul( power( b, 2 ), fdiv( c, 16 ) ), fneg( fdiv( fmul( b, d ), 4 ) ) ] ) roots = solveCubicPolynomial( 1, fdiv( f, 2 ), fdiv( fsub( power( f, 2 ), fmul( 4, h ) ), 16 ), fneg( fdiv( power( g, 2 ), 64 ) ) ) y1 = roots[ 0 ] y2 = roots[ 1 ] y3 = roots[ 2 ] # pick two non-zero roots, if there are two imaginary roots, use them if y1 == 0: root1 = y2 root2 = y3 elif y2 == 0: root1 = y1 root2 = y3 elif y3 == 0: root1 = y1 root2 = y2 elif im( y1 ) != 0: root1 = y1 if im( y2 ) != 0: root2 = y2 else: root2 = y3 else: root1 = y2 root2 = y3 # more variables... p = sqrt( root1 ) q = sqrt( root2 ) r = fdiv( fneg( g ), fprod( [ 8, p, q ] ) ) s = fneg( fdiv( b, 4 ) ) # put together the 4 roots x1 = fsum( [ p, q, r, s ] ) x2 = fsum( [ p, fneg( q ), fneg( r ), s ] ) x3 = fsum( [ fneg( p ), q, fneg( r ), s ] ) x4 = fsum( [ fneg( p ), fneg( q ), r, s ] ) return [ chop( x1 ), chop( x2 ), chop( x3 ), chop( x4 ) ]
def solveCubicPolynomial( a, b, c, d ): # pylint: disable=invalid-name ''' This function applies the cubic formula to solve a polynomial with coefficients of a, b, c and d. ''' if mp.dps < 50: mp.dps = 50 if a == 0: return solveQuadraticPolynomial( b, c, d ) f = fdiv( fsub( fdiv( fmul( 3, c ), a ), fdiv( power( b, 2 ), power( a, 2 ) ) ), 3 ) g = fdiv( fadd( fsub( fdiv( fmul( 2, power( b, 3 ) ), power( a, 3 ) ), fdiv( fprod( [ 9, b, c ] ), power( a, 2 ) ) ), fdiv( fmul( 27, d ), a ) ), 27 ) h = fadd( fdiv( power( g, 2 ), 4 ), fdiv( power( f, 3 ), 27 ) ) # all three roots are the same if h == 0: x1 = fneg( root( fdiv( d, a ), 3 ) ) x2 = x1 x3 = x2 # two imaginary and one real root elif h > 0: r = fadd( fneg( fdiv( g, 2 ) ), sqrt( h ) ) if r < 0: s = fneg( root( fneg( r ), 3 ) ) else: s = root( r, 3 ) t = fsub( fneg( fdiv( g, 2 ) ), sqrt( h ) ) if t < 0: u = fneg( root( fneg( t ), 3 ) ) else: u = root( t, 3 ) x1 = fsub( fadd( s, u ), fdiv( b, fmul( 3, a ) ) ) real = fsub( fdiv( fneg( fadd( s, u ) ), 2 ), fdiv( b, fmul( 3, a ) ) ) imaginary = fdiv( fmul( fsub( s, u ), sqrt( 3 ) ), 2 ) x2 = mpc( real, imaginary ) x3 = mpc( real, fneg( imaginary ) ) # all real roots else: j = sqrt( fsub( fdiv( power( g, 2 ), 4 ), h ) ) k = acos( fneg( fdiv( g, fmul( 2, j ) ) ) ) if j < 0: l = fneg( root( fneg( j ), 3 ) ) else: l = root( j, 3 ) m = cos( fdiv( k, 3 ) ) n = fmul( sqrt( 3 ), sin( fdiv( k, 3 ) ) ) p = fneg( fdiv( b, fmul( 3, a ) ) ) x1 = fsub( fmul( fmul( 2, l ), cos( fdiv( k, 3 ) ) ), fdiv( b, fmul( 3, a ) ) ) x2 = fadd( fmul( fneg( l ), fadd( m, n ) ), p ) x3 = fadd( fmul( fneg( l ), fsub( m, n ) ), p ) return [ chop( x1 ), chop( x2 ), chop( x3 ) ]
def get_binary(self, item): def _comma(a, b): if not isinstance(a, mpmath.matrix): a = mpmath.matrix([[a]]) if not isinstance(b, mpmath.matrix): b = mpmath.matrix([[b]]) assert a.rows == b.rows, 'matrix rows not equal' r = mpmath.matrix(a.rows, a.cols + b.cols) for i in range(a.rows): for j in range(a.cols): r[(i, j)] = a[(i, j)] for j in range(b.cols): r[(i, j + a.cols)] = b[(i, j)] return r def _semicolon(a, b): if not isinstance(a, mpmath.matrix): a = mpmath.matrix([[a]]) if not isinstance(b, mpmath.matrix): b = mpmath.matrix([[b]]) assert a.cols == b.cols, 'matrix cols not equal' r = mpmath.matrix(a.rows + b.rows, a.cols) for j in range(a.cols): for i in range(a.rows): r[(i, j)] = a[(i, j)] for i in range(b.rows): r[(i + a.rows, j)] = b[(i, j)] return r def _mul(a, b): r = a * b if isinstance(r, mpmath.matrix) and r.rows == 1 and r.cols == 1: return r[(0, 0)] else: return r def _dot(a, b): if isinstance(a, mpmath.matrix) and isinstance(b, mpmath.matrix): if a.rows == b.rows == 1 and a.cols == b.cols: return _mul(a, b.transpose()) elif a.cols == b.cols == 1 and a.rows == b.rows: return _mul(a.transpose(), b) return _mul(a, b) def _cross(a, b): try: la = OpList.__analyse_triple(a) lb = OpList.__analyse_triple(b) r = [ la[1] * lb[2] - la[2] * lb[1], la[2] * lb[0] - la[0] * lb[2], la[0] * lb[1] - la[1] * lb[0] ] if a.cols == b.cols == 1: return mpmath.matrix([[i] for i in r]) if a.rows == b.rows == 1: return mpmath.matrix([r]) else: raise Exception except: return _mul(a, b) return { '+': calc2.BinaryOperator('+', lambda x, y: x + y, 30), '-': calc2.BinaryOperator('-', lambda x, y: x - y, 30), '*': calc2.BinaryOperator('*', _dot, 31), 'x': calc2.BinaryOperator('x', _cross, 31), '×': calc2.BinaryOperator('x', _cross, 31), '/': calc2.BinaryOperator('/', lambda x, y: x / y, 31), 'mod': calc2.BinaryOperator('mod', mpmath.fmod, 31), '^': calc2.BinaryOperator('^', mpmath.power, 32), 'rt': calc2.BinaryOperator('y_/x', lambda y, x: mpmath.root(x, y), 32), '_/': calc2.BinaryOperator('y_/x', lambda y, x: mpmath.root(x, y), 32), '√': calc2.BinaryOperator('y_/x', lambda y, x: mpmath.root(x, y), 32), 'log': calc2.BinaryOperator('blogA', lambda b, a: OpList.__log(b, a), 32), 'P': calc2.BinaryOperator( 'nPr', lambda n, r: mpmath.factorial(n) / mpmath.factorial(n - r), 50), 'C': calc2.BinaryOperator( 'nCr', lambda n, r: mpmath.factorial(n) / (mpmath.factorial(n - r) * mpmath.factorial(r)), 50), 'E': calc2.BinaryOperator( '*10^', lambda s, e: mpmath.fmul(s, mpmath.power(10, e)), 70), ',': calc2.BinaryOperator(',', _comma, 22), ';': calc2.BinaryOperator(';', _semicolon, 21), }[item]
def calculateGeometricMean( args ): if isinstance( args[ 0 ], ( list, RPNGenerator ) ): return [ calculateGeometricMean( list( arg ) ) for arg in args ] return root( fprod( args ), len( args ) )
def describeIntegerOperator(n): indent = ' ' * 4 print() print(int(n), 'is:') if isOdd(n): print(indent + 'odd') elif isEven(n): print(indent + 'even') if isPrime(n): isPrimeFlag = True print(indent + 'prime') elif n > 3: isPrimeFlag = False print(indent + 'composite') else: isPrimeFlag = False if isKthPower(n, 2): print(indent + 'the ' + getShortOrdinalName(sqrt(n)) + ' square number') if isKthPower(n, 3): print(indent + 'the ' + getShortOrdinalName(cbrt(n)) + ' cube number') for i in arange(4, fadd(ceil(log(fabs(n), 2)), 1)): if isKthPower(n, i): print(indent + 'the ' + getShortOrdinalName(root(n, i)) + ' ' + getNumberName(i, True) + ' power') # triangular guess = findPolygonalNumber(n, 3) if getNthPolygonalNumber(guess, 3) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' triangular number') # pentagonal guess = findPolygonalNumber(n, 5) if getNthPolygonalNumber(guess, 5) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' pentagonal number') # hexagonal guess = findPolygonalNumber(n, 6) if getNthPolygonalNumber(guess, 6) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' hexagonal number') # heptagonal guess = findPolygonalNumber(n, 7) if getNthPolygonalNumber(guess, 7) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' heptagonal number') # octagonal guess = findPolygonalNumber(n, 8) if getNthPolygonalNumber(guess, 8) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' octagonal number') # nonagonal guess = findPolygonalNumber(n, 9) if getNthPolygonalNumber(guess, 9) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' nonagonal number') # decagonal guess = findPolygonalNumber(n, 10) if getNthPolygonalNumber(guess, 10) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' decagonal number') # if n > 1: # for i in range( 11, 101 ): # if getNthPolygonalNumber( findPolygonalNumber( n, i ), i ) == n: # print( indent + str( i ) + '-gonal' ) # centered triangular guess = findCenteredPolygonalNumber(n, 3) if getNthCenteredPolygonalNumber(guess, 3) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered triangular') # centered square guess = findCenteredPolygonalNumber(n, 4) if getNthCenteredPolygonalNumber(guess, 4) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered square number') # centered pentagonal guess = findCenteredPolygonalNumber(n, 5) if getNthCenteredPolygonalNumber(guess, 5) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered pentagonal number') # centered hexagonal guess = findCenteredPolygonalNumber(n, 6) if getNthCenteredPolygonalNumber(guess, 6) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered hexagonal number') # centered heptagonal guess = findCenteredPolygonalNumber(n, 7) if getNthCenteredPolygonalNumber(guess, 7) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered heptagonal number') # centered octagonal guess = findCenteredPolygonalNumber(n, 8) if getNthCenteredPolygonalNumber(guess, 8) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered octagonal number') # centered nonagonal guess = findCenteredPolygonalNumber(n, 9) if getNthCenteredPolygonalNumber(guess, 9) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered nonagonal number') # centered decagonal guess = findCenteredPolygonalNumber(n, 10) if getNthCenteredPolygonalNumber(guess, 10) == n: print(indent + 'the ' + getShortOrdinalName(guess) + ' centered decagonal number') # pandigital if isPandigital(n): print(indent + 'pandigital') # for i in range( 4, 21 ): # if isBaseKPandigital( n, i ): # print( indent + 'base ' + str( i ) + ' pandigital' ) # Fibonacci result = findInput(n, fib, lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Fibonacci number') # Tribonacci result = findInput(n, lambda n: getNthKFibonacciNumber(n, 3), lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Tribonacci number') # Tetranacci result = findInput(n, lambda n: getNthKFibonacciNumber(n, 4), lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Tetranacci number') # Pentanacci result = findInput(n, lambda n: getNthKFibonacciNumber(n, 5), lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Pentanacci number') # Hexanacci result = findInput(n, lambda n: getNthKFibonacciNumber(n, 6), lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Hexanacci number') # Heptanacci result = findInput(n, lambda n: getNthKFibonacciNumber(n, 7), lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Heptanacci number') # Octanacci result = findInput(n, lambda n: getNthKFibonacciNumber(n, 8), lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Octanacci number') # Lucas numbers result = findInput(n, getNthLucasNumber, lambda n: fmul(log10(n), 5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Lucas number') # base-k repunits if n > 1: for i in range(2, 21): result = findInput(n, lambda x: getNthBaseKRepunit(x, i), lambda n: log(n, i), minimum=1) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' base-' + str(i) + ' repunit') # Jacobsthal numbers result = findInput(n, getNthJacobsthalNumber, lambda n: fmul(log(n), 1.6)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Jacobsthal number') # Padovan numbers result = findInput(n, getNthPadovanNumber, lambda n: fmul(log10(n), 9)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Padovan number') # Fibonorial numbers result = findInput(n, getNthFibonorial, lambda n: sqrt(fmul(log(n), 10))) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Fibonorial number') # Mersenne primes result = findInput(n, getNthMersennePrime, lambda n: fadd(fmul(log(log(sqrt(n))), 2.7), 3)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Mersenne prime') # perfect number result = findInput(n, getNthPerfectNumber, lambda n: fmul(log(log(n)), 2.6)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' perfect number') # Mersenne exponent result = findInput(n, getNthMersenneExponent, lambda n: fmul(log(n), 2.7), maximum=50) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Mersenne exponent') if not isPrimeFlag and n != 1 and n <= LARGEST_NUMBER_TO_FACTOR: # deficient if isDeficient(n): print(indent + 'deficient') # abundant if isAbundant(n): print(indent + 'abundant') # k_hyperperfect for i in sorted(list(set(sorted( downloadOEISSequence(34898)[:500]))))[1:]: if i > n: break if isKHyperperfect(n, i): print(indent + str(i) + '-hyperperfect') break # smooth for i in getPrimes(2, 50): if isSmooth(n, i): print(indent + str(i) + '-smooth') break # rough previousPrime = 2 for i in getPrimes(2, 50): if not isRough(n, i): print(indent + str(previousPrime) + '-rough') break previousPrime = i # is_semiprime if isSemiprime(n): print(indent + 'semiprime') # is_sphenic elif isSphenic(n): print(indent + 'sphenic') elif isSquareFree(n): print(indent + 'square-free') # powerful if isPowerful(n): print(indent + 'powerful') # factorial result = findInput(n, getNthFactorial, lambda n: power(log10(n), 0.92)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' factorial number') # alternating factorial result = findInput(n, getNthAlternatingFactorial, lambda n: fmul(sqrt(log(n)), 0.72)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' alternating factorial number') # double factorial if n == 1: result = (True, 1) else: result = findInput(n, getNthDoubleFactorial, lambda n: fdiv(power(log(log(n)), 4), 7)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' double factorial number') # hyperfactorial result = findInput(n, getNthHyperfactorial, lambda n: fmul(sqrt(log(n)), 0.8)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' hyperfactorial number') # subfactorial result = findInput(n, getNthSubfactorial, lambda n: fmul(log10(n), 1.1)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' subfactorial number') # superfactorial if n == 1: result = (True, 1) else: result = findInput(n, getNthSuperfactorial, lambda n: fadd(sqrt(log(n)), 1)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' superfactorial number') # pernicious if isPernicious(n): print(indent + 'pernicious') # pronic if isPronic(n): print(indent + 'pronic') # Achilles if isAchillesNumber(n): print(indent + 'an Achilles number') # antiharmonic if isAntiharmonic(n): print(indent + 'antiharmonic') # unusual if isUnusual(n): print(indent + 'unusual') # hyperperfect for i in range(2, 21): if isKHyperperfect(n, i): print(indent + str(i) + '-hyperperfect') # Ruth-Aaron if isRuthAaronNumber(n): print(indent + 'a Ruth-Aaron number') # Smith numbers if isSmithNumber(n): print(indent + 'a Smith number') # base-k Smith numbers for i in range(2, 10): if isBaseKSmithNumber(n, i): print(indent + 'a base-' + str(i) + ' Smith number') # order-k Smith numbers for i in range(2, 11): if isOrderKSmithNumber(n, i): print(indent + 'an order-' + str(i) + ' Smith number') # polydivisible if isPolydivisible(n): print(indent + 'polydivisible') # Carol numbers result = findInput(n, getNthCarolNumber, lambda n: fmul(log10(n), fdiv(5, 3))) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Carol number') # Kynea numbers result = findInput(n, getNthKyneaNumber, lambda n: fmul(log10(n), fdiv(5, 3))) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Kynea number') # Leonardo numbers result = findInput(n, getNthLeonardoNumber, lambda n: fsub(log(n, phi), fdiv(1, phi))) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Leonardo number') # Thabit numbers result = findInput(n, getNthThabitNumber, lambda n: fmul(log10(n), 3.25)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Thabit number') # Carmmichael if isCarmichaelNumber(n): print(indent + 'a Carmichael number') # narcissistic if isNarcissistic(n): print(indent + 'narcissistic') # PDI if isPerfectDigitalInvariant(n): print(indent + 'a perfect digital invariant') # PDDI if isPerfectDigitToDigitInvariant(n, 10): print(indent + 'a perfect digit-to-digit invariant in base 10') # Kaprekar if isKaprekarNumber(n): print(indent + 'a Kaprekar number') # automorphic if isAutomorphic(n): print(indent + 'automorphic') # trimorphic if isTrimorphic(n): print(indent + 'trimorphic') # k-morphic for i in range(4, 11): if isKMorphic(n, i): print(indent + str(i) + '-morphic') # bouncy if isBouncy(n): print(indent + 'bouncy') # step number if isStepNumber(n): print(indent + 'a step number') # Apery numbers result = findInput(n, getNthAperyNumber, lambda n: fadd(fdiv(log(n), 1.5), 1)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Apery number') # Delannoy numbers result = findInput(n, getNthDelannoyNumber, lambda n: fmul(log10(n), 1.35)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Delannoy number') # Schroeder numbers result = findInput(n, getNthSchroederNumber, lambda n: fmul(log10(n), 1.6)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Schroeder number') # Schroeder-Hipparchus numbers result = findInput(n, getNthSchroederHipparchusNumber, lambda n: fdiv(log10(n), 1.5)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Schroeder-Hipparchus number') # Motzkin numbers result = findInput(n, getNthMotzkinNumber, log) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Motzkin number') # Pell numbers result = findInput(n, getNthPellNumber, lambda n: fmul(log(n), 1.2)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Pell number') # Sylvester numbers if n > 1: result = findInput(n, getNthSylvesterNumber, lambda n: sqrt(sqrt(log(n)))) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' Sylvester number') # partition numbers result = findInput(n, getPartitionNumber, lambda n: power(log(n), 1.56)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' partition number') # menage numbers result = findInput(n, getNthMenageNumber, lambda n: fdiv(log10(n), 1.2)) if result[0]: print(indent + 'the ' + getShortOrdinalName(result[1]) + ' menage number') print() print(int(n), 'has:') # number of digits digits = log10(n) if isInteger(digits): digits += 1 else: digits = ceil(digits) print(indent + str(int(digits)) + ' digit' + ('s' if digits > 1 else '')) # digit sum print(indent + 'a digit sum of ' + str(int(sumDigits(n)))) # digit product digitProduct = multiplyDigits(n) print(indent + 'a digit product of ' + str(int(digitProduct))) # non-zero digit product if digitProduct == 0: print(indent + 'a non-zero digit product of ' + str(int(multiplyNonzeroDigits(n)))) if not isPrimeFlag and n != 1 and n <= LARGEST_NUMBER_TO_FACTOR: # factors factors = getFactors(n) factorCount = len(factors) print(indent + str(factorCount) + ' prime factor' + ('s' if factorCount > 1 else '') + ': ' + ', '.join([str(int(i)) for i in factors])) # number of divisors divisorCount = int(getDivisorCount(n)) print(indent + str(divisorCount) + ' divisor' + ('s' if divisorCount > 1 else '')) if n <= LARGEST_NUMBER_TO_FACTOR: print(indent + 'a divisor sum of ' + str(int(getSigma(n)))) print(indent + 'a Stern value of ' + str(int(getNthSternNumber(n)))) calkinWilf = getNthCalkinWilf(n) print(indent + 'a Calkin-Wilf value of ' + str(int(calkinWilf[0])) + '/' + str(int(calkinWilf[1]))) print(indent + 'a Mobius value of ' + str(int(getNthMobiusNumber(n)))) print(indent + 'a radical of ' + str(int(getRadical(n)))) print(indent + 'a Euler phi value of ' + str(int(getEulerPhi(n)))) print(indent + 'a digital root of ' + str(int(getDigitalRoot(n)))) if hasUniqueDigits(n): print(indent + 'unique digits') print(indent + 'a multiplicative persistence of ' + str(int(getPersistence(n)))) print(indent + 'an Erdos persistence of ' + str(int(getErdosPersistence(n)))) if n > 9 and isIncreasing(n): if not isDecreasing(n): print(indent + 'increasing digits') elif n > 9 and isDecreasing(n): print(indent + 'decreasing digits') print() return n
def getSuperRoot( n, k ): k = fsub( real_int( k ), 1 ) value = fmul( k, log( n ) ) return root( fdiv( value, lambertw( value ) ), k )
trigUnit = TrigUnit.Radians Backend.engineFunction("=", lambda op: mpmath.mpmathify(op), operands=1) Backend.engineFunction("+", lambda op: op[0] + op[1]) Backend.engineFunction("-", lambda op: op[0] - op[1]) Backend.engineFunction("mul", lambda op: op[0] * op[1]) Backend.engineFunction("div", lambda op: op[0] / op[1]) Backend.engineFunction("^", lambda op: op[0] ** op[1]) Backend.engineFunction("10^x", lambda op: 10 ** op, operands=1) Backend.engineFunction("x^2", lambda op: op ** 2, operands=1) Backend.engineFunction("neg", lambda op: op * -1, operands=1) Backend.engineFunction("%", lambda op: op[0] * op[1] / 100) Backend.engineFunction("inv", lambda op: 1 / op, operands=1) Backend.engineFunction("sqrt", lambda op: mpmath.sqrt(op), operands=1) Backend.engineFunction("nthroot", lambda op: mpmath.root(op[0], op[1])) Backend.engineFunction("log", lambda op: mpmath.log(op, b=10), operands=1) Backend.engineFunction("ln", lambda op: mpmath.log(op), operands=1) Backend.engineFunction("e^x", lambda op: mpmath.exp(op), operands=1) Backend.engineFunction("factorial", lambda op: mpmath.factorial(op), operands=1) @Backend.engineFunction(operands=-1) def addall(op): expr = op[0] for i in range(1, len(op)): expr = expr + op[i] return expr @Backend.engineFunction(operands=-1) def suball(op): expr = op[0]
def describeInteger( n ): if n < 1: raise ValueError( "'describe' requires a positive integer argument" ) indent = ' ' * 4 print( ) print( real_int( n ), 'is:' ) if isOdd( n ): print( indent + 'odd' ) elif isEven( n ): print( indent + 'even' ) if isPrimeNumber( n ): isPrime = True print( indent + 'prime' ) elif n > 3: isPrime = False print( indent + 'composite' ) else: isPrime = False if isKthPower( n, 2 ): print( indent + 'the ' + getShortOrdinalName( sqrt( n ) ) + ' square number' ) if isKthPower( n, 3 ): print( indent + 'the ' + getShortOrdinalName( cbrt( n ) ) + ' cube number' ) for i in arange( 4, fadd( ceil( log( fabs( n ), 2 ) ), 1 ) ): if isKthPower( n, i ): print( indent + 'the ' + getShortOrdinalName( root( n, i ) ) + ' ' + \ getNumberName( i, True ) + ' power' ) # triangular guess = findPolygonalNumber( n, 3 ) if getNthPolygonalNumber( guess, 3 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' triangular number' ) # pentagonal guess = findPolygonalNumber( n, 5 ) if getNthPolygonalNumber( guess, 5 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' pentagonal number' ) # hexagonal guess = findPolygonalNumber( n, 6 ) if getNthPolygonalNumber( guess, 6 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' hexagonal number' ) # heptagonal guess = findPolygonalNumber( n, 7 ) if getNthPolygonalNumber( guess, 7 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' heptagonal number' ) # octagonal guess = findPolygonalNumber( n, 8 ) if getNthPolygonalNumber( guess, 8 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' octagonal number' ) # nonagonal guess = findPolygonalNumber( n, 9 ) if getNthPolygonalNumber( guess, 9 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' nonagonal number' ) # decagonal guess = findPolygonalNumber( n, 10 ) if getNthPolygonalNumber( guess, 10 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' decagonal number' ) #if n > 1: # for i in range( 11, 101 ): # if getNthPolygonalNumber( findPolygonalNumber( n, i ), i ) == n: # print( indent + str( i ) + '-gonal' ) # centered triangular guess = findCenteredPolygonalNumber( n, 3 ) if getNthCenteredPolygonalNumber( guess, 3 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered triangular' ) # centered square guess = findCenteredPolygonalNumber( n, 4 ) if getNthCenteredPolygonalNumber( guess, 4 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered square number' ) # centered pentagonal guess = findCenteredPolygonalNumber( n, 5 ) if getNthCenteredPolygonalNumber( guess, 5 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered pentagonal number' ) # centered hexagonal guess = findCenteredPolygonalNumber( n, 6 ) if getNthCenteredPolygonalNumber( guess, 6 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered hexagonal number' ) # centered heptagonal guess = findCenteredPolygonalNumber( n, 7 ) if getNthCenteredPolygonalNumber( guess, 7 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered heptagonal number' ) # centered octagonal guess = findCenteredPolygonalNumber( n, 8 ) if getNthCenteredPolygonalNumber( guess, 8 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered octagonal number' ) # centered nonagonal guess = findCenteredPolygonalNumber( n, 9 ) if getNthCenteredPolygonalNumber( guess, 9 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered nonagonal number' ) # centered decagonal guess - findCenteredPolygonalNumber( n, 10 ) if getNthCenteredPolygonalNumber( guess, 10 ) == n: print( indent + 'the ' + getShortOrdinalName( guess ) + ' centered decagonal number' ) # pandigital if isPandigital( n ): print( indent + 'pandigital' ) #for i in range( 4, 21 ): # if isBaseKPandigital( n, i ): # print( indent + 'base ' + str( i ) + ' pandigital' ) # Fibonacci result = findInput( n, fib, lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Fibonacci number' ) # Tribonacci result = findInput( n, lambda n : getNthKFibonacciNumber( n, 3 ), lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Tribonacci number' ) # Tetranacci result = findInput( n, lambda n : getNthKFibonacciNumber( n, 4 ), lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Tetranacci number' ) # Pentanacci result = findInput( n, lambda n : getNthKFibonacciNumber( n, 5 ), lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Pentanacci number' ) # Hexanacci result = findInput( n, lambda n : getNthKFibonacciNumber( n, 6 ), lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Hexanacci number' ) # Heptanacci result = findInput( n, lambda n : getNthKFibonacciNumber( n, 7 ), lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Heptanacci number' ) # Octanacci result = findInput( n, lambda n : getNthKFibonacciNumber( n, 8 ), lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Octanacci number' ) # Lucas numbers result = findInput( n, getNthLucasNumber, lambda n: fmul( log10( n ), 5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Lucas number' ) # base-k repunits if n > 1: for i in range( 2, 21 ): result = findInput( n, lambda x: getNthBaseKRepunit( x, i ), lambda n: log( n, i ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' base-' + str( i ) + ' repunit' ) # Jacobsthal numbers result = findInput( n, getNthJacobsthalNumber, lambda n: fmul( log( n ), 1.6 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Jacobsthal number' ) # Padovan numbers result = findInput( n, getNthPadovanNumber, lambda n: fmul( log10( n ), 9 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Padovan number' ) # Fibonorial numbers result = findInput( n, getNthFibonorial, lambda n: sqrt( fmul( log( n ), 10 ) ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Fibonorial number' ) # Mersenne primes result = findInput( n, getNthMersennePrime, lambda n: fadd( fmul( log( log( sqrt( n ) ) ), 2.7 ), 3 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Mersenne prime' ) ## perfect number result = findInput( n, getNthPerfectNumber, lambda n: fmul( log( log( n ) ), 2.6 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' perfect number' ) # Mersenne exponent result = findInput( n, getNthMersenneExponent, lambda n: fmul( log( n ), 2.7 ), max=50 ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Mersenne exponent' ) if not isPrime and n != 1 and n <= largestNumberToFactor: # deficient if isDeficient( n ): print( indent + 'deficient' ) # abundant if isAbundant( n ): print( indent + 'abundant' ) # k_hyperperfect for i in sorted( list( set( sorted( downloadOEISSequence( 34898 )[ : 500 ] ) ) ) )[ 1 : ]: if i > n: break if isKHyperperfect( n, i ): print( indent + str( i ) + '-hyperperfect' ) break # smooth for i in getPrimes( 2, 50 ): if isSmooth( n, i ): print( indent + str( i ) + '-smooth' ) break # rough previousPrime = 2 for i in getPrimes( 2, 50 ): if not isRough( n, i ): print( indent + str( previousPrime ) + '-rough' ) break previousPrime = i # is_semiprime if isSemiprime( n ): print( indent + 'semiprime' ) # is_sphenic elif isSphenic( n ): print( indent + 'sphenic' ) elif isSquareFree( n ): print( indent + 'square-free' ) # powerful if isPowerful( n ): print( indent + 'powerful' ) # factorial result = findInput( n, getNthFactorial, lambda n: power( log10( n ), 0.92 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' factorial number' ) # alternating factorial result = findInput( n, getNthAlternatingFactorial, lambda n: fmul( sqrt( log( n ) ), 0.72 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' alternating factorial number' ) # double factorial if n == 1: result = ( True, 1 ) else: result = findInput( n, getNthDoubleFactorial, lambda n: fdiv( power( log( log( n ) ), 4 ), 7 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' double factorial number' ) # hyperfactorial result = findInput( n, getNthHyperfactorial, lambda n: fmul( sqrt( log( n ) ), 0.8 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' hyperfactorial number' ) # subfactorial result = findInput( n, getNthSubfactorial, lambda n: fmul( log10( n ), 1.1 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' subfactorial number' ) # superfactorial if n == 1: result = ( True, 1 ) else: result = findInput( n, getNthSuperfactorial, lambda n: fadd( sqrt( log( n ) ), 1 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' superfactorial number' ) # pernicious if isPernicious( n ): print( indent + 'pernicious' ) # pronic if isPronic( n ): print( indent + 'pronic' ) # Achilles if isAchillesNumber( n ): print( indent + 'an Achilles number' ) # antiharmonic if isAntiharmonic( n ): print( indent + 'antiharmonic' ) # unusual if isUnusual( n ): print( indent + 'unusual' ) # hyperperfect for i in range( 2, 21 ): if isKHyperperfect( n, i ): print( indent + str( i ) + '-hyperperfect' ) # Ruth-Aaron if isRuthAaronNumber( n ): print( indent + 'a Ruth-Aaron number' ) # Smith numbers if isSmithNumber( n ): print( indent + 'a Smith number' ) # base-k Smith numbers for i in range( 2, 10 ): if isBaseKSmithNumber( n, i ): print( indent + 'a base-' + str( i ) + ' Smith number' ) # order-k Smith numbers for i in range( 2, 11 ): if isOrderKSmithNumber( n, i ): print( indent + 'an order-' + str( i ) + ' Smith number' ) # polydivisible if isPolydivisible( n ): print( indent + 'polydivisible' ) # Carol numbers result = findInput( n, getNthCarolNumber, lambda n: fmul( log10( n ), fdiv( 5, 3 ) ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Carol number' ) # Kynea numbers result = findInput( n, getNthKyneaNumber, lambda n: fmul( log10( n ), fdiv( 5, 3 ) ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Kynea number' ) # Leonardo numbers result = findInput( n, getNthLeonardoNumber, lambda n: fsub( log( n, phi ), fdiv( 1, phi ) ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Leonardo number' ) # Riesel numbers result = findInput( n, getNthRieselNumber, lambda n: fmul( log( n ), 1.25 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Riesel number' ) # Thabit numbers result = findInput( n, getNthThabitNumber, lambda n: fmul( log10( n ), 3.25 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Thabit number' ) # Carmmichael if isCarmichaelNumber( n ): print( indent + 'a Carmichael number' ) # narcissistic if isNarcissistic( n ): print( indent + 'narcissistic' ) # PDI if isPerfectDigitalInvariant( n ): print( indent + 'a perfect digital invariant' ) # PDDI if isPerfectDigitToDigitInvariant( n, 10 ): print( indent + 'a perfect digit-to-digit invariant in base 10' ) # Kaprekar if isKaprekar( n ): print( indent + 'a Kaprekar number' ) # automorphic if isAutomorphic( n ): print( indent + 'automorphic' ) # trimorphic if isTrimorphic( n ): print( indent + 'trimorphic' ) # k-morphic for i in range( 4, 11 ): if isKMorphic( n, i ): print( indent + str( i ) + '-morphic' ) # bouncy if isBouncy( n ): print( indent + 'bouncy' ) # step number if isStepNumber( n ): print( indent + 'a step number' ) # Apery numbers result = findInput( n, getNthAperyNumber, lambda n: fadd( fdiv( log( n ), 1.5 ), 1 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Apery number' ) # Delannoy numbers result = findInput( n, getNthDelannoyNumber, lambda n: fmul( log10( n ), 1.35 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Delannoy number' ) # Schroeder numbers result = findInput( n, getNthSchroederNumber, lambda n: fmul( log10( n ), 1.6 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Schroeder number' ) # Schroeder-Hipparchus numbers result = findInput( n, getNthSchroederHipparchusNumber, lambda n: fdiv( log10( n ), 1.5 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Schroeder-Hipparchus number' ) # Motzkin numbers result = findInput( n, getNthMotzkinNumber, lambda n: log( n ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Motzkin number' ) # Pell numbers result = findInput( n, getNthPellNumber, lambda n: fmul( log( n ), 1.2 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Pell number' ) # Sylvester numbers if n > 1: result = findInput( n, getNthSylvesterNumber, lambda n: sqrt( sqrt( log( n ) ) ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' Sylvester number' ) # partition numbers result = findInput( n, getPartitionNumber, lambda n: power( log( n ), 1.56 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' partition number' ) # menage numbers result = findInput( n, getNthMenageNumber, lambda n: fdiv( log10( n ), 1.2 ) ) if result[ 0 ]: print( indent + 'the ' + getShortOrdinalName( result[ 1 ] ) + ' menage number' ) print( ) print( int( n ), 'has:' ) # number of digits digits = log10( n ) if isInteger( digits ): digits += 1 else: digits = ceil( digits ) print( indent + str( int( digits ) ) + ' digit' + ( 's' if digits > 1 else '' ) ) # digit sum print( indent + 'a digit sum of ' + str( int( sumDigits( n ) ) ) ) # digit product digitProduct = multiplyDigits( n ) print( indent + 'a digit product of ' + str( int( digitProduct ) ) ) # non-zero digit product if digitProduct == 0: print( indent + 'a non-zero digit product of ' + str( int( multiplyNonzeroDigits( n ) ) ) ) if not isPrime and n != 1 and n <= largestNumberToFactor: # factors factors = getFactors( n ) factorCount = len( factors ) print( indent + str( factorCount ) + ' prime factor' + ( 's' if factorCount > 1 else '' ) + \ ': ' + ', '.join( [ str( int( i ) ) for i in factors ] ) ) # number of divisors divisorCount = int( getDivisorCount( n ) ) print( indent + str( divisorCount ) + ' divisor' + ( 's' if divisorCount > 1 else '' ) ) if n <= largestNumberToFactor: print( indent + 'a sum of divisors of ' + str( int( getSigma( n ) ) ) ) print( indent + 'a Stern value of ' + str( int( getNthStern( n ) ) ) ) calkin_wilf = getNthCalkinWilf( n ) print( indent + 'a Calkin-Wilf value of ' + str( int( calkin_wilf[ 0 ] ) ) + '/' + str( int( calkin_wilf[ 1 ] ) ) ) print( indent + 'a Mobius value of ' + str( int( getMobius( n ) ) ) ) print( indent + 'a radical of ' + str( int( getRadical( n ) ) ) ) print( indent + 'a Euler phi value of ' + str( int( getEulerPhi( n ) ) ) ) print( indent + 'a digital root of ' + str( int( getDigitalRoot( n ) ) ) ) if hasUniqueDigits( n ): print( indent + 'unique digits' ) print( indent + 'a multiplicative persistence of ' + str( int( getPersistence( n ) ) ) ) print( indent + 'an Erdos persistence of ' + str( int( getErdosPersistence( n ) ) ) ) if n > 9 and isIncreasing( n ): if not isDecreasing( n ): print( indent + 'increasing digits' ) elif n > 9 and isDecreasing( n ): print( indent + 'decreasing digits' ) print( ) return n
def getSuperRootOperator(n, k): '''Returns the positive, real kth super root of n.''' k = fsub(k, 1) value = fmul(k, log(n)) return root(fdiv(value, lambertw(value)), k)
def getSuperRoots( n, k ): k = fsub( real_int( k ), 1 ) factors = [ fmul( i, root( k, k ) ) for i in unitroots( int( k ) ) ] base = root( fdiv( log( n ), lambertw( fmul( k, log( n ) ) ) ), k ) return [ fmul( i, base ) for i in factors ]
def solveCubicPolynomial( a, b, c, d ): if mp.dps < 50: mp.dps = 50 if a == 0: return solveQuadraticPolynomial( b, c, d ) f = fdiv( fsub( fdiv( fmul( 3, c ), a ), fdiv( power( b, 2 ), power( a, 2 ) ) ), 3 ) g = fdiv( fadd( fsub( fdiv( fmul( 2, power( b, 3 ) ), power( a, 3 ) ), fdiv( fprod( [ 9, b, c ] ), power( a, 2 ) ) ), fdiv( fmul( 27, d ), a ) ), 27 ) h = fadd( fdiv( power( g, 2 ), 4 ), fdiv( power( f, 3 ), 27 ) ) # all three roots are the same if h == 0: x1 = fneg( root( fdiv( d, a ), 3 ) ) x2 = x1 x3 = x2 # two imaginary and one real root elif h > 0: r = fadd( fneg( fdiv( g, 2 ) ), sqrt( h ) ) if r < 0: s = fneg( root( fneg( r ), 3 ) ) else: s = root( r, 3 ) t = fsub( fneg( fdiv( g, 2 ) ), sqrt( h ) ) if t < 0: u = fneg( root( fneg( t ), 3 ) ) else: u = root( t, 3 ) x1 = fsub( fadd( s, u ), fdiv( b, fmul( 3, a ) ) ) real = fsub( fdiv( fneg( fadd( s, u ) ), 2 ), fdiv( b, fmul( 3, a ) ) ) imaginary = fdiv( fmul( fsub( s, u ), sqrt( 3 ) ), 2 ) x2 = mpc( real, imaginary ) x3 = mpc( real, fneg( imaginary ) ) # all real roots else: j = sqrt( fsub( fdiv( power( g, 2 ), 4 ), h ) ) k = acos( fneg( fdiv( g, fmul( 2, j ) ) ) ) if j < 0: l = fneg( root( fneg( j ), 3 ) ) else: l = root( j, 3 ) m = cos( fdiv( k, 3 ) ) n = fmul( sqrt( 3 ), sin( fdiv( k, 3 ) ) ) p = fneg( fdiv( b, fmul( 3, a ) ) ) x1 = fsub( fmul( fmul( 2, l ), cos( fdiv( k, 3 ) ) ), fdiv( b, fmul( 3, a ) ) ) x2 = fadd( fmul( fneg( l ), fadd( m, n ) ), p ) x3 = fadd( fmul( fneg( l ), fsub( m, n ) ), p ) return [ chop( x1 ), chop( x2 ), chop( x3 ) ]
'pi': mp.pi, 'degree': mp.degree, #pi / 180 'e': mp.e, 'phi': mp.phi, #golden ratio = 1.61803... 'euler': mp.euler, #euler's constance = 0.577216... 'mpf': ['primitive', [lambda x, y: mp.mpf(str(x)), None]], 'mpc': ['primitive', [lambda x, y: mp.mpc(x, y[0]), None]], # 'sqrt': ['primitive', [lambda x, y: mp.sqrt(x), None]], 'cbrt': ['primitive', [lambda x, y: mp.cbrt(x), None]], 'root': ['primitive', [lambda x, y: mp.root(x, y[0]), None]], # y's root 'unitroots': ['primitive', [lambda x, y: Vector(mp.unitroots(x)), None]], # 'hypot': ['primitive', [lambda x, y: mp.hypot(x, y[0]), None]], # sqrt(x**2+y**2) # 'sin': ['primitive', [lambda x, y: mp.sin(x), None]], 'cos': ['primitive', [lambda x, y: mp.cos(x), None]], 'tan': ['primitive', [lambda x, y: mp.tan(x), None]], 'sinpi': ['primitive', [lambda x, y: mp.sinpi(x), None]], #sin(x * pi) 'cospi': ['primitive', [lambda x, y: mp.cospi(x), None]], 'sec': ['primitive', [lambda x, y: mp.sec(x), None]], 'csc': ['primitive', [lambda x, y: mp.csc(x), None]], 'cot': ['primitive', [lambda x, y: mp.cot(x), None]], 'asin': ['primitive', [lambda x, y: mp.asin(x), None]], 'acos': ['primitive', [lambda x, y: mp.acos(x), None]],
def solveQuarticPolynomial( _a, _b, _c, _d, _e ): if mp.dps < 50: mp.dps = 50 # maybe it's really an order-3 polynomial if _a == 0: return solveCubicPolynomial( _b, _c, _d, _e ) # degenerate case, just return the two real and two imaginary 4th roots of the # constant term divided by the 4th root of a elif _b == 0 and _c == 0 and _d == 0: e = fdiv( _e, _a ) f = root( _a, 4 ) x1 = fdiv( root( fneg( e ), 4 ), f ) x2 = fdiv( fneg( root( fneg( e ), 4 ) ), f ) x3 = fdiv( mpc( 0, root( fneg( e ), 4 ) ), f ) x4 = fdiv( mpc( 0, fneg( root( fneg( e ), 4 ) ) ), f ) return [ x1, x2, x3, x4 ] # otherwise we have a regular quartic to solve b = fdiv( _b, _a ) c = fdiv( _c, _a ) d = fdiv( _d, _a ) e = fdiv( _e, _a ) # we turn the equation into a cubic that we can solve f = fsub( c, fdiv( fmul( 3, power( b, 2 ) ), 8 ) ) g = fsum( [ d, fdiv( power( b, 3 ), 8 ), fneg( fdiv( fmul( b, c ), 2 ) ) ] ) h = fsum( [ e, fneg( fdiv( fmul( 3, power( b, 4 ) ), 256 ) ), fmul( power( b, 2 ), fdiv( c, 16 ) ), fneg( fdiv( fmul( b, d ), 4 ) ) ] ) y1, y2, y3 = solveCubicPolynomial( 1, fdiv( f, 2 ), fdiv( fsub( power( f, 2 ), fmul( 4, h ) ), 16 ), fneg( fdiv( power( g, 2 ), 64 ) ) ) # pick two non-zero roots, if there are two imaginary roots, use them if y1 == 0: root1 = y2 root2 = y3 elif y2 == 0: root1 = y1 root2 = y3 elif y3 == 0: root1 = y1 root2 = y2 elif im( y1 ) != 0: root1 = y1 if im( y2 ) != 0: root2 = y2 else: root2 = y3 else: root1 = y2 root2 = y3 # more variables... p = sqrt( root1 ) q = sqrt( root2 ) r = fdiv( fneg( g ), fprod( [ 8, p, q ] ) ) s = fneg( fdiv( b, 4 ) ) # put together the 4 roots x1 = fsum( [ p, q, r, s ] ) x2 = fsum( [ p, fneg( q ), fneg( r ), s ] ) x3 = fsum( [ fneg( p ), q, fneg( r ), s ] ) x4 = fsum( [ fneg( p ), fneg( q ), r, s ] ) return [ chop( x1 ), chop( x2 ), chop( x3 ), chop( x4 ) ]