pickle_attempt_for_web3.py

# pickle_attempt_for_web3.py

from time import time as t
import pickle
import gmpy2
import random
import os.path

def int_digits_num(n):
    """
    Given an integer, (positive, 0, or negative), or an expression that
    evaluates to an integer, returns the number of digits in the integer.
    """
    from math import log10
    if not isinstance(n, int):
        raise TypeError("WTF you didn't pass me an int")
    if n == 0:
        return 1
    n = abs(n)
    return int(log10(n)) + 1

def int_commas(n):
    """
    inserts commas into integers and returns the string

    E.g. -12345678 -> -12,345,789
    """
    return format(n, ',d')

def printTime(timeStart, timeEnd):
    from mycalc import hmsToText
    timeElapsed = timeEnd - timeStart
    if timeElapsed > 60:
        print("Time was", hmsToText(timeElapsed))
    else:
        print("Time was %.4g seconds" % timeElapsed)

def randIntOfGivenLength(length):
    """
    Return a random int of a given number of digits
    """
    return random.randint(10**(length-1), 10**length - 1)

def findFactor(n, startingAt):
    """
    Written by Kent Johnson
    """
    limit = int(n**.5) + 1
    x = startingAt
    while x < limit:
        if not n % x:
            return x
        x += 2
    return False

def factorsOfInteger(n):
    """
    Return list of prime factors of n.
    Returns [n] if n is prime.
    Re-written largely by Kent Johnson
    """
    factors = []
    if n == 1:
        return [1]
    # Get the factors of two out of the way to simplify findFactor
    while n % 2 == 0:
        factors.append(2)
        n = n // 2
    lastFactor = 3
    r = n
    while True:
        factor = findFactor(r, lastFactor)
        if not factor:
            # r is prime
            if r == 1: # This is needed, at least for powers of 2
                break
            factors.append(r)
            break
        factors.append(factor)
        lastFactor = factor
        r = r // factor # correcting an error in previous versions
    if len(factors) == 1:
        return factors
    factors[-1] = int(factors[-1]) # without this some last factors are floats, ending in .0
    return factors

D = {}
if os.path.getsize('factors.txt') == 2:
    #The file exists, but is empty; leave it alone
    pass

elif os.path.exists('factors.txt'):
    #The file exists and is not empty: use it
    f = open("factors.txt", 'rb')
    data = pickle.load(f)
    f.close
    D = data

else:
    # create the file and close it
    f = open("factors.txt", 'wb')
    f.close

print("D has", int_commas(len(D)), "entries")
begin = 1000100000
w = 900000
end = begin + w

add_flag = 0
if add_flag == 1:
    t0 = t()
    for n in range(begin, end):
        factors_list = factorsOfInteger(n)
        D[n] = factors_list

    t1 = t()
    printTime(t0,t1)
    print()
    print("D now has", int_commas(len(D)), "entries")

print()

while True:
    oldnew_flag = 0
    print("Enter a positive integer OR")
    print("Enter nothing to generate an 18-digit integer OR")
    print("Enter a zero to close the program.")
    print()
    s = input("> ")

    if "10**" in s:
        n = 10**(int(s[4:]))
        plus = input("plus: ")
        if plus == '':
            plus = 0
        else:
            plus = int(plus)
        n += plus

    elif s != '':
        n = int(s)

        if n >= 10**19:
            print(n, "is too big: calculation might take too long.")
            print("Choose another n")
            print()
            continue

        elif gmpy2.is_prime(n) and len(str(n)) >= 18:
            print(n, "is prime -- will take too long.")
            print("Choose another n")
            print()
            continue

    elif s == '':
        n = randIntOfGivenLength(18)
        print("n =", n, "a random 18-digit integer")
        n, r = find_large_prime_factors_of_large_ints(n)

        if gmpy2.is_prime(n):
            print(n, "is prime -- will take too long.")
            print("Choose another n")
            print()
            continue

        elif r == 1:
            print(n, "has a large prime factor -- will take too long.")
            print("Choose another n")
            print()
            continue

    if n == 0:
        print("D has", int_commas(len(D)), "entries")
        f = open("factors.txt", 'wb')
        pickle.dump(D, f)
        f.close
        break

    t0 = t()

    try:
        factors = D[n]
        print("the factors of", int_commas(n), "are", factors)
        oldnew_flag = 1
        print("OLD")

    except KeyError:
        factors = factorsOfInteger(n)
        print("the factors of", int_commas(n), "are", factors)
        D[n] = factors
        oldnew_flag = 2
        print("NEW")

    t1 = t()

    print()

    #print(D.items())
    #print(D.values())
    #print(D.keys())
    printTime(t0,t1)
    if oldnew_flag == 1:
        print("OLD ENTRY")
    elif oldnew_flag == 2:
        print("NEW ENTRY")
    print("D has", int_commas(len(D)), "entries")
    print()