Пример #1
0
 def expmod(base, exp, m):
     if exp == 0:
         return 1
     elif even(exp):
         return square(expmod(base, exp / 2, m)) % m
     else:
         return base * expmod(base, exp - 1, m) % m
Пример #2
0
 def test_letrec_odd_even(self):
     from util import n, odd, even
     eq_(
         eval(
             letrec([(odd, lamda([n], if_(eq(n, 0), 0, even(sub(n, 1))))),
                     (even, lamda([n], if_(eq(n, 0), 1, odd(sub(n, 1)))))],
                    odd(3))), 1)
Пример #3
0
 def fast_expt(b, n):
     if n == 0:
         return 1
     elif even(n):
         return square(fast_expt(b, n / 2))
     else:
         return b * fast_expt(b, n - 1)
Пример #4
0
 def test_letrec_odd_even(self):
     from util import n
     odd, even = MacroVar('odd'), MacroVar('even')
     eq_(
         eval(
             letrec([(odd, macro([n], if_(eq(n, 0), 0, even(sub(n, 1))))),
                     (even, macro([n], if_(eq(n, 0), 1, odd(sub(n, 1)))))],
                    odd(3))), 1)
Пример #5
0
def term(k):
    if even(k):
        a = k + 2
        b = a + 1
    else:
        a = k + 3
        b = a - 1

    return a / b
Пример #6
0
def expmod(base, exp, m):
    logl("(" + str(base) + ", " + str(exp) + ", " + str(m) + ")")

    if exp == 0:
        return 1
    elif even(exp):
        return square(expmod(base, exp / 2, m)) % m
    else:
        return base * expmod(base, exp - 1, m) % m
Пример #7
0
    def mult_iter(r, a, b):  
        logl("(" + str(r) + ", " + str(a) + ", " + str(b) + ")")

        if b == 0:
            return r
        elif even(b):
            return mult_iter(r, double(a), halve(b))
        else:
            return mult_iter(r + a, a, b - 1)
Пример #8
0
    def term(k):
        if k == 0 or k == n:
            factor = 1
        elif even(k):
            factor = 2
        else:
            factor = 4

        return factor * y(k)
Пример #9
0
def fast_expt(a, b):
    logl("(" + str(a) + ", " + str(b) + ")")

    if b == 0:
        return 0
    elif even(b):
        return double(fast_expt(a, halve(b)))
    else:
        return a + fast_expt(a, b - 1)
Пример #10
0
def fast_expt(b, n):
    logl("(" + str(b) + ", " + str(n) + ")")

    if n == 0:
        return 1
    elif even(n):
        return square(fast_expt(b, n / 2))
    else:
        return b * fast_expt(b, n - 1)
Пример #11
0
    def expt_iter(a, b, n):
        logl("(" + str(a) + ", " + str(b) + ", " + str(n) + ")")

        if n == 0:
            return a
        elif even(n):
            return expt_iter(a, square(b), n / 2)
        else:
            return expt_iter(a * b, b, n - 1)
Пример #12
0
def search_for_prime(n, i):
    if i == 0:
        return
    elif even(n):
        n += 1
    else:
        n += 2

    if timed_prime_test(n):
        i -= 1

    search_for_prime(n, i)
Пример #13
0
def fib_iter(a, b, p, q, count):
    logl("(" + str(a) + ", " + str(b) + ", " + str(p) + ", " + str(q) + ", " +
         str(count) + ")")

    if count == 0:
        return b
    elif even(count):
        return fib_iter(a, b,
                        square(p) + square(q), 2 * p * q + square(q),
                        count / 2)
    else:
        return fib_iter((b * q) + (a * q) + (a * p), (b * p) + (a * q), p, q,
                        (count - 1))
Пример #14
0
    def expmod(base, exp, m):
        def sqrmod(x):
            def check_sqrt(x, square):
                if square == 1 and x != 1 and x != m - 1:
                    return 0

                return square

            return check_sqrt(x, square(x)) % m

        if exp == 0:
            return 1
        elif even(exp):
            return sqrmod(expmod(base, exp / 2, m))
        else:
            return base * expmod(base, exp - 1, m) % m
Пример #15
0
import util

fib = [1,2]
finalfib = []
finalsum = 0



while True:
    fib.append(fib[len(fib)-1] + fib[len(fib) - 2])
    if fib[len(fib) -1 ] > 4000000:
        fib.pop()
        break
for digit in fib:
    if util.even(digit):
        finalsum = finalsum + digit
print(finalsum)
Пример #16
0
 def test_letrec_odd_even(self):
   from util import n, odd, even  
   eq_(eval(letrec([(odd, lamda([n], if_(eq(n,0), 0, even(sub(n,1))))),
                   (even, lamda([n], if_(eq(n,0), 1, odd(sub(n, 1)))))],
                 odd(3))), 1)
Пример #17
0
 def test_letrec_odd_even(self):
   from util import n
   odd, even  = MacroVar('odd'), MacroVar('even')  
   eq_(eval(letrec([(odd, macro([n], if_(eq(n,0), 0, even(sub(n,1))))),
                   (even, macro([n], if_(eq(n,0), 1, odd(sub(n, 1)))))],
                 odd(3))), 1)