chrislo-sourceclassifier 0.2.0

data/sources/python/objinst.python

@@ -0,0 +1,53 @@
+#!/usr/bin/python 
+# http://www.bagley.org/~doug/shootout/
+
+import sys
+
+class Toggle:
+    def __init__(self, start_state):
+        self.bool = start_state
+    def value(self):
+        return(self.bool)
+    def activate(self):
+        self.bool = not self.bool
+        return(self)
+
+class NthToggle(Toggle):
+    def __init__(self, start_state, max_counter):
+        Toggle.__init__(self, start_state)
+        self.count_max = max_counter
+        self.counter = 0
+    def activate(self):
+        self.counter += 1
+        if (self.counter >= self.count_max):
+            self.bool = not self.bool
+            self.counter = 0
+        return(self)
+
+
+def main():
+    NUM = int(sys.argv[1])
+    if NUM < 1:
+        NUM = 1
+
+    toggle = Toggle(1)
+    for i in xrange(0,5):
+        if toggle.activate().value():
+            print "true"
+        else:
+            print "false"
+    for i in xrange(0,NUM):
+        toggle = Toggle(1)
+
+    print ""
+
+    ntoggle = NthToggle(1, 3)
+    for i in xrange(0,8):
+        if ntoggle.activate().value():
+            print "true"
+        else:
+            print "false"
+    for i in xrange(0,NUM):
+        ntoggle = NthToggle(1, 3)
+
+main()

data/sources/python/partialsums.python

@@ -0,0 +1,37 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Josh Goldfoot
+# modified by Mike Klaas
+# modified by Dani Nanz 2007-08-28, also considering input from Tupteq
+
+import sys
+import math
+
+def doit(n, sin=math.sin, cos=math.cos):
+
+    alt = -1.
+    twothirds = 2. / 3.
+    k = s0 = 1.
+    s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = 0.
+    while k <= n:
+        k2 = k * k
+        k3 = k2 * k
+        ks, kc = sin(k), cos(k)
+        alt = -alt
+        s0 += twothirds ** k
+        s1 += k ** -.5
+        s2 += 1. / (k * (k + 1.))
+        s3 += 1. / (k3 * ks * ks)
+        s4 += 1. / (k3 * kc * kc)
+        s5 += 1. / k
+        s6 += 1. / k2
+        s7 += alt / k
+        s8 += alt / (k + k - 1.)
+        k += 1.      
+    fmt = '\n%0.9f\t'
+    nms = ['(2/3)^k', 'k^-0.5', '1/k(k+1)', 'Flint Hills', 'Cookson Hills',
+           'Harmonic', 'Riemann Zeta', 'Alternating Harmonic', 'Gregory']
+    print (fmt[1:] + fmt.join(nms)) % (s0, s1, s2, s3, s4, s5, s6, s7, s8)
+    
+doit(float(sys.argv[1]))

data/sources/python/partialsums.python-2.python

@@ -0,0 +1,35 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Daniel Nanz 2008-03-12
+
+
+import sys
+import numpy
+
+def doit(n, np=numpy):
+
+    k = np.arange(1, n + 1)
+    alt = (2 * (k & 1)) - 1
+    k = np.double(k)
+    k2 = k * k
+    k3 = k * k2
+    kc = np.cos(k)
+    ks = np.sin(k)
+    
+    sums = (((2. / 3.) ** k).sum() + 1.,
+            (k ** -.5).sum(),
+            (1. / (k * (k + 1.))).sum(),
+            (1. / (k3 * ks * ks)).sum(),
+            (1. / (k3 * kc * kc)).sum(),
+            (1. / k).sum(),
+            (1. / k2).sum(),
+            (alt / k).sum(),
+            (alt / (k + k - 1.)).sum())
+
+    fmt = '\n%0.9f\t'
+    nms = ['(2/3)^k', 'k^-0.5', '1/k(k+1)', 'Flint Hills', 'Cookson Hills',
+           'Harmonic', 'Riemann Zeta', 'Alternating Harmonic', 'Gregory']
+    print (fmt[1:] + fmt.join(nms)) % sums
+
+doit(int(sys.argv[1]))

data/sources/python/partialsums.python-3.python

@@ -0,0 +1,48 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# contributed by Daniel Nanz 2008-03-18
+
+import sys
+import numpy
+
+def doit(n, buf_size=50000, np=numpy):
+
+    n_low = 1
+    if buf_size <= n:
+        todo = buf_size
+    else:
+        todo = n
+    sums = np.zeros(9, dtype=np.double)
+    sums[0] += 1.
+    while todo > 0:
+        n_high = n_low + todo
+        k = np.arange(n_low, n_high, dtype=np.int8)
+        alt = (2 * (k & 1)) - 1
+        k = np.arange(n_low, n_high, dtype=np.double)
+        k2 = k * k
+        k3 = k * k2
+        ks = np.sin(k)
+        kc = np.cos(k)
+        sums += map(np.sum,
+                    ((2. / 3.) ** k,
+                     k ** -.5,
+                     1. / (k * (k + 1.)),
+                     1. / (k3 * ks * ks),
+                     1. / (k3 * kc * kc),
+                     1. / k,
+                     1. / k2,
+                     alt / k,
+                     alt / (k + k - 1.)))
+        n_low = n_high
+        if (n - buf_size) > n_low:
+            todo = buf_size
+        else:
+            todo = n - n_low + 1
+
+    fmt = '\n%0.9f\t'
+    nms = ['(2/3)^k', 'k^-0.5', '1/k(k+1)', 'Flint Hills', 'Cookson Hills',
+           'Harmonic', 'Riemann Zeta', 'Alternating Harmonic', 'Gregory']
+    print (fmt[1:] + fmt.join(nms)) % tuple(sums)
+
+doit(int(sys.argv[1]))

data/sources/python/pidigits.python

@@ -0,0 +1,38 @@
+
+import sys
+from itertools import *
+
+def gen_x():
+    return imap(lambda k: (k, 4*k + 2, 0, 2*k + 1), count(1))
+
+def compose((aq, ar, as_, at), (bq, br, bs, bt)):
+    return (aq * bq,
+            aq * br + ar * bt,
+            as_ * bq + at * bs,
+            as_ * br + at * bt)
+
+def extract((q, r, s, t), j):
+    return (q*j + r) // (s*j + t)
+
+def pi_digits():
+    z = (1, 0, 0, 1)
+    x = gen_x()
+    while 1:
+        y = extract(z, 3)
+        while y != extract(z, 4):
+            z = compose(z, x.next())
+            y = extract(z, 3)
+        z = compose((10, -10*y, 0, 1), z)
+        yield y
+
+def main():
+    n = int(sys.argv[1])
+    digits = pi_digits()
+    width = 10
+    for i in xrange(width, n+1, width):
+        print "%s\t:%d" % ("".join(imap(str, islice(digits, width))), i)
+    if n % width > 0:
+        print "%s\t:%d" % ("".join(imap(str, islice(digits, n % width))).ljust(width), n)
+
+
+main()

data/sources/python/pidigits.python-3.python

@@ -0,0 +1,63 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by - not known -
+# modified by Pilho Kim (first GMP version)
+# modified by Dani Nanz (2007-09-14)
+
+import sys
+import itertools
+import gmpy
+
+
+mpz0, mpz1 = gmpy.mpz(0), gmpy.mpz(1)
+mpz2, mpz3 = gmpy.mpz(2), gmpy.mpz(3)
+mpz4, mpz10 = gmpy.mpz(4), gmpy.mpz(10)
+
+
+def gen_x(k=mpz0):
+
+    while 1:
+        k += mpz1
+        yield (k, mpz4 * k + mpz2, mpz0, mpz2 * k + mpz1)
+
+
+def compose((a, b, c, d), (e, f, g, h)):  
+
+    return (a * e,
+            a * f + b * h,
+            c * e + d * g,
+            c * f + d * h)
+
+
+def extract((a, b, c, d), j):
+    return (a * j + b) // (c * j + d)
+
+
+def pi_digits():
+
+    z = (mpz1, mpz0, mpz0, mpz1)
+    x = gen_x()
+    while 1:
+        y = extract(z, mpz3)
+        while y != extract(z, mpz4):
+            z = compose(z, x.next())
+            y = extract(z, mpz3)
+        z = compose((mpz10, -mpz10 * y, mpz0, mpz1), z)
+        yield str(y)
+
+
+def main(islice=itertools.islice):
+
+    n = int(sys.argv[1])
+    digits = pi_digits()
+    w = 10
+    out = []
+    for i in xrange(w, n+1, w):
+        out.extend([''.join(islice(digits, w)), i])
+    print ('%s\t:%d\n' * (len(out) / 2)) % tuple(out),
+    if n % w > 0:
+        print "%s\t:%d" % (''.join(islice(digits, n % w)).ljust(w), n)
+
+
+main()

data/sources/python/pidigits.python-4.python

@@ -0,0 +1,24 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Dani Nanz (2007-09-21)
+
+import sys
+import gmpy
+
+def main(n):
+
+    pi = str(gmpy.pi(int(3.35 * n)))
+    pi_tmp = ''.join([pi[0], pi[2:]])
+    pistr = pi_tmp[0 : n]
+    w = 10
+    out = []
+    for i in xrange(0, n - w + 1, w):
+        out.extend([pistr[i : i + w] , i + w])
+    print ('%s\t:%d\n' * (len(out) / 2)) % tuple(out),
+    if n % w > 0:
+        print "%s\t:%d" % ((pistr[-(n % w):]).ljust(w), n)
+
+
+main(int(sys.argv[1]))
+

data/sources/python/process.python

@@ -0,0 +1,51 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org/
+#
+# contributed by Kevin Carson
+
+from threading import Thread
+from Queue import Queue
+from sys import argv
+
+
+class link(Thread) :
+    def __init__(self, next) :
+        Thread.__init__(self)
+        self.next = next
+        self.inq = Queue(1)
+
+    def run(self) :
+        self.store = self.inq.get()
+        self.next.inq.put(self.store + 1)
+
+
+class terminus(Thread) :
+    def __init__(self) :
+        Thread.__init__(self)
+        self.inq = Queue(1)
+
+    def run(self) :
+        self.sum = self.inq.get()
+        print "%d" % self.sum
+
+
+N = int(argv[1])
+
+# Create the chain of threads then fire them up
+chain_length = N + 1
+tasks = [None] * chain_length
+tasks[N] = terminus()
+tasks[N - 1] = link(tasks[N])
+
+for i in xrange(N - 2, -1, -1) :
+    tasks[i] = link(tasks[i + 1])
+
+for i in xrange(chain_length) :
+    tasks[i].start()
+
+# Feed the chain with an integer message
+tasks[0].inq.put(0)
+
+# Wait upon the terminus process
+tasks[N].join()

data/sources/python/process.python-2.python

@@ -0,0 +1,133 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org/
+#
+# contributed by Antoine Pitrou
+
+import sys
+
+#
+# A very simple cooperative threads package using generators,
+#
+
+def singleton(cls):
+    instance = []
+    def wrapper(*args, **kargs):
+        if not instance:
+            instance.append(cls(*args, **kargs))
+        return instance[0]
+    return wrapper
+
+class WaitObject(object):
+    def __init__(self, switcher=None):
+        self.switcher = switcher or global_switcher()
+        self.waiters = []
+    
+    def get_waiter(self):
+        try:
+            return self.waiters.pop()
+        except IndexError:
+            return None
+
+    def add_waiter(self, waiter):
+        self.waiters.append(waiter)
+    
+    def set_ready(self, ready):
+        self.switcher.set_ready(self, ready)
+
+class Queue(WaitObject):
+    def __init__(self):
+        WaitObject.__init__(self)
+        self.data = []
+
+    def put(self, value):
+        self.data.append(value)
+        self.set_ready(True)
+    
+    def get(self):
+        self.set_ready(len(self.data) > 1)
+        return self.data.pop(0)
+
+class _Ready(WaitObject):
+    def __init__(self):
+        WaitObject.__init__(self)
+        self.set_ready(True)
+
+# Special-casing Ready as a singleton is important for scalability
+Ready = singleton(_Ready)
+
+class Thread(object):
+    def __init__(self, switcher=None):
+        self.switcher = switcher or global_switcher()
+        self.switcher.add_thread(self)
+
+class Switcher(object):
+    def __init__(self):
+        self.threads = set()
+        self.ready_objects = set()
+    
+    def add_thread(self, thread):
+        Ready().add_waiter(thread)
+        thread.runner = thread.run()
+        self.threads.add(thread)
+
+    def set_ready(self, wait_object, ready):
+        if ready:
+            self.ready_objects.add(wait_object)
+        else:
+            self.ready_objects.discard(wait_object)
+
+    def run(self):
+        while len(self.threads):
+            for r in self.ready_objects:
+                thread = r.get_waiter()
+                if not thread or not thread.runner:
+                    continue
+                try:
+                    wait_object = thread.runner.next()
+                except StopIteration:
+                    thread.runner = None
+                    self.threads.remove(thread)
+                else:
+                    wait_object.add_waiter(thread)
+                break
+
+global_switcher = singleton(Switcher)
+
+#
+# Here the problem-specific definitions
+#
+
+class Link(Thread):
+    def __init__(self, next):
+        Thread.__init__(self)
+        self.next = next
+        self.incoming = Queue()
+
+    def run(self):
+        yield self.incoming
+        self.store = self.incoming.get()
+        self.next.incoming.put(self.store + 1)
+
+class Terminus(Thread):
+    def __init__(self):
+        Thread.__init__(self)
+        self.incoming = Queue()
+
+    def run(self):
+        yield self.incoming
+        self.sum = self.incoming.get()
+        print "%d" % self.sum
+
+def main():
+    N = int(sys.argv[1])
+
+    # Create the chain of threads then run them all
+    task = Terminus()
+    for i in xrange(N):
+        task = Link(task)
+    task.incoming.put(0)
+    
+    global_switcher().run()
+
+main()