Ejemplo n.º 1
0
def invcdf(p):
    """
    Inverse of the CDF of the raised cosine distribution.
    """
    with mpmath.extradps(5):
        p = mpmath.mpf(p)

        if p < 0 or p > 1:
            return mpmath.nan
        if p == 0:
            return -mpmath.pi
        if p == 1:
            return mpmath.pi

        if p < 0.094:
            x = _poly_approx(mpmath.cbrt(12 * mpmath.pi * p)) - mpmath.pi
        elif p > 0.906:
            x = mpmath.pi - _poly_approx(mpmath.cbrt(12 * mpmath.pi * (1 - p)))
        else:
            y = mpmath.pi * (2 * p - 1)
            y2 = y**2
            x = y * _p2(y2) / _q2(y2)

        solver = 'mnewton'
        x = mpmath.findroot(f=lambda t: cdf(t) - p,
                            x0=x,
                            df=lambda t: (1 + mpmath.cos(t)) / (2 * mpmath.pi),
                            df2=lambda t: -mpmath.sin(t) / (2 * mpmath.pi),
                            solver=solver)

        return x
	def __compute_roots(self,a,c,d):
		from mpmath import mpf, mpc, sqrt, cbrt
		assert(all([isinstance(_,mpf) for _ in [a,c,d]]))
		Delta = self.__Delta
		# NOTE: this was the original function used for root finding.
		# proots, err = polyroots([a,0,c,d],error=True,maxsteps=5000000)
		# Computation of the cubic roots.
		# TODO special casing.
		u_list = [mpf(1),mpc(-1,sqrt(3))/2,mpc(-1,-sqrt(3))/2]
		Delta0 = -3 * a * c
		Delta1 = 27 * a * a * d
		C1 = cbrt((Delta1 + sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
		C2 = cbrt((Delta1 - sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
		if abs(C1) > abs(C2):
			C = C1
		else:
			C = C2
		proots = [(-1 / (3 * a)) * (u * C + Delta0 / (u * C)) for u in u_list]
		# NOTE: we ignore any residual imaginary part that we know must come from numerical artefacts.
		if Delta < 0:
			# Sort the roots following the convention: complex with negative imaginary, real, complex with positive imaginary.
			# Then assign the roots following the P convention (e2 real root, e1 complex with positive imaginary).
			e3,e2,e1 = sorted(proots,key = lambda c: c.imag)
		else:
			# The convention in this case is to sort in descending order.
			e1,e2,e3 = sorted([_.real for _ in proots],reverse = True)
		return e1,e2,e3
Ejemplo n.º 3
0
 def __cubic_roots(self,a,c,d):
     from mpmath import mpf, mpc, sqrt, cbrt
     assert(all([isinstance(_,mpf) for _ in [a,c,d]]))
     Delta = -4 * a * c*c*c - 27 * a*a * d*d
     self.__Delta = Delta
     # NOTE: this was the original function used for root finding.
     # proots, err = polyroots([a,0,c,d],error=True,maxsteps=5000000)
     # Computation of the cubic roots.
     u_list = [mpf(1),mpc(-1,sqrt(3))/2,mpc(-1,-sqrt(3))/2]
     Delta0 = -3 * a * c
     Delta1 = 27 * a * a * d
     # Here we have two choices for the value from sqrt, positive or negative. Since C
     # is used as a denominator below, we pick the choice with the greatest absolute value.
     # http://en.wikipedia.org/wiki/Cubic_function
     # This should handle the case g2 = 0 gracefully.
     C1 = cbrt((Delta1 + sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
     C2 = cbrt((Delta1 - sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
     if abs(C1) > abs(C2):
         C = C1
     else:
         C = C2
     proots = [(-1 / (3 * a)) * (u * C + Delta0 / (u * C)) for u in u_list]
     # NOTE: we ignore any residual imaginary part that we know must come from numerical artefacts.
     if Delta < 0:
         # Sort the roots following the convention: complex with negative imaginary, real, complex with positive imaginary.
         # Then assign the roots following the P convention (e2 real root, e1 complex with positive imaginary).
         e3,e2,e1 = sorted(proots,key = lambda c: c.imag)
     else:
         # The convention in this case is to sort in descending order.
         e1,e2,e3 = sorted([_.real for _ in proots],reverse = True)
     return e1,e2,e3
Ejemplo n.º 4
0
 def __cubic_roots(self, a, c, d):
     from mpmath import mpf, mpc, sqrt, cbrt
     assert (all([isinstance(_, mpf) for _ in [a, c, d]]))
     Delta = -4 * a * c * c * c - 27 * a * a * d * d
     self.__Delta = Delta
     # NOTE: this was the original function used for root finding.
     # proots, err = polyroots([a,0,c,d],error=True,maxsteps=5000000)
     # Computation of the cubic roots.
     u_list = [mpf(1), mpc(-1, sqrt(3)) / 2, mpc(-1, -sqrt(3)) / 2]
     Delta0 = -3 * a * c
     Delta1 = 27 * a * a * d
     # Here we have two choices for the value from sqrt, positive or negative. Since C
     # is used as a denominator below, we pick the choice with the greatest absolute value.
     # http://en.wikipedia.org/wiki/Cubic_function
     # This should handle the case g2 = 0 gracefully.
     C1 = cbrt(
         (Delta1 + sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) /
         2)
     C2 = cbrt(
         (Delta1 - sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) /
         2)
     if abs(C1) > abs(C2):
         C = C1
     else:
         C = C2
     proots = [(-1 / (3 * a)) * (u * C + Delta0 / (u * C)) for u in u_list]
     # NOTE: we ignore any residual imaginary part that we know must come from numerical artefacts.
     if Delta < 0:
         # Sort the roots following the convention: complex with negative imaginary, real, complex with positive imaginary.
         # Then assign the roots following the P convention (e2 real root, e1 complex with positive imaginary).
         e3, e2, e1 = sorted(proots, key=lambda c: c.imag)
     else:
         # The convention in this case is to sort in descending order.
         e1, e2, e3 = sorted([_.real for _ in proots], reverse=True)
     return e1, e2, e3
Ejemplo n.º 5
0
def DedekindEtaA4(tau):
    ''' Compute the derivative of the Dedekind Eta function for imaginary argument tau. 
        Numerically. '''
    try:
        import mpmath as mp
        mpmath_loaded = True
    except ImportError:
        mpmath_loaded = False 
    
    return mp.cbrt(0.5*mp.jtheta(2,0,mp.exp(-mp.pi*tau))*mp.jtheta(3,0,mp.exp(-mp.pi*tau))*mp.jtheta(4,0,mp.exp(-mp.pi*tau)))
Ejemplo n.º 6
0
def DedekindEtaA(tau):
    ''' Alternative definition of the Dedekind Eta function in terms 
        of the Jacobi theta function. 10x faster computation. 
        http://functions.wolfram.com/EllipticFunctions/DedekindEta/27/01/02/'''
    try:
        import mpmath as mp
        mpmath_loaded = True
    except ImportError:
        mpmath_loaded = False 
    
    return mp.cbrt(0.5*mp.jtheta(1,0,mp.exp(-mp.pi*tau),1)) 
Ejemplo n.º 7
0
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
Ejemplo n.º 8
0
from itertools import combinations
import matplotlib.pyplot as plt
from mpmath import cbrt
import sys
import OrbitData

times = []
masses = None
positions = []
for time, bodies, _ in OrbitData.read(sys.stdin):
	times.append(time)
	positions.append(map(lambda b: b[1:3], bodies))
	masses = map(lambda b: b[0], bodies)

scale = min(masses)
masses = [12*cbrt(m/scale)**2 for m in masses]

print "Read all data"

def update_plot(i, scat, pos, mass):
	scat.set_offsets(pos[i])
	scat.set_sizes(mass)
	return scat

minx = min(map(lambda p: min(map(lambda c: c[0], p)), positions))
maxx = max(map(lambda p: max(map(lambda c: c[0], p)), positions))
miny = min(map(lambda p: min(map(lambda c: c[1], p)), positions))
maxy = max(map(lambda p: max(map(lambda c: c[1], p)), positions))

xbuf = (maxx - minx)/10
maxx += xbuf
Ejemplo n.º 9
0
 def inverse_function(y):
     return cbrt((y - coefficients[-1]) / coefficients[0])
Ejemplo n.º 10
0
def test_cbrt_imag_dd_mp():
    ans = cbrt_imag_dd(2.718281828459045, 1.4456468917292502e-16,
                       3.141592653589793, 1.2246467991473532e-16)
    mp_ans = mp.cbrt(mp.e + mp.pi * 1j)
    assert abs(mp_ans.real - (mp.mpf(ans[0]) + mp.mpf(ans[1]))) < 1e-30
    assert abs(mp_ans.imag - (mp.mpf(ans[2]) + mp.mpf(ans[3]))) < 1e-30
Ejemplo n.º 11
0
    if x == 0: return 1000
    return abs(2 * ap.sqrt(x) - x**2 / 2)


def approximate(errfunc, startsize=1, startnum=0):  # peice of shit is broken
    estim = ap.mpf(startnum)
    while error(estim) != 0 and startnum > -ap.mp.dps:
        value = ap.mpf(10)**startsize
        for d in range(10):
            print((d + 1) * value)
            print(f"value {estim} vs {estim + value}")
            print(f"errone is {error(estim)}")
            print(f"errtwo is {error(estim + value)}")
            if error(estim + value) > error(estim):
                print("break")
                input()
                break
            input()
            estim += value
        startsize -= 1
    return estim


#print(approximate(error, 0, 2.5))

# f**k this

# (2 * sqrt(x)) - (x ^ 2 / 2) = 0
# from wolfram alpha: 2 * cuberoot(2)
print(str(2 * ap.cbrt(2)))
Ejemplo n.º 12
0
    while ndigits >= 0:
        magnitude = base**ndigits
        d = n // magnitude
        n = n % magnitude
        nstring += digitmap[d]
        ndigits -= 1

    return nstring


def is_palindrome(n):
    nstr = str(n)
    while len(nstr) > 1:
        if nstr[0] != nstr[-1]:
            return False
        nstr = nstr[1:-1]
    return True


i = 0

while True:
    if mpmath.cbrt(i**2) % 1 == 0:
        base = to_base(i)
        if is_palindrome(base):
            print(f"number is {i}")
            print(f"{i}^2 ({i**2}) is cube of {int(mpmath.cbrt(i**2))}")
            print(f"number in base 63 is {base}")
            input()
    i += 1
Ejemplo n.º 13
0
def getPlasticConstant( ):
    '''Computes and returns the Plastic constant.'''
    term = fmul( 12, sqrt( 69 ) )
    return fdiv( fadd( cbrt( fadd( 108, term ) ), cbrt( fsub( 108, term ) ) ), 6 )
Ejemplo n.º 14
0
def getPlasticConstant( ):
    '''Computes and returns the Plastic constant.'''
    term = fmul( 12, sqrt( 69 ) )
    return fdiv( fadd( cbrt( fadd( 108, term ) ), cbrt( fsub( 108, term ) ) ), 6 )
Ejemplo n.º 15
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
Ejemplo n.º 16
0
 'imag': ['primitive', [lambda x, y: x.imag, None]],
 '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]],