chrislo-sourceclassifier 0.2.0

data/sources/python/chameneosredux.python-2.python

@@ -0,0 +1,122 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# contributed by Daniel Nanz 2008-04-10
+
+import sys
+import thread
+import time
+
+# colors and matching
+creature_colors = ['blue', 'red', 'yellow']
+
+def complement(c1, c2):
+
+    if c1 == c2: return c1
+    if c1 == 'blue':
+        if c2 == 'red': return 'yellow'
+        return 'red'
+    if c1 == 'red':
+        if c2 == 'blue': return 'yellow'
+        return 'blue'
+    if c2 == 'blue': return 'red'
+    return 'blue'
+
+
+compl_dict = dict(((c1, c2), complement(c1, c2))
+                  for c1 in creature_colors
+                  for c2 in creature_colors)
+
+
+def check_complement(colors=creature_colors, compl=compl_dict):
+
+    for c1 in colors:
+        for c2 in colors:
+            print '%s + %s -> %s' % (c1, c2, compl[(c1, c2)])
+    print ''
+
+
+# reporting
+def spellout(n):
+    
+    numbers = ['zero', 'one', 'two', 'three', 'four',
+               'five', 'six', 'seven', 'eight', 'nine']
+    return ' ' + ' '.join(numbers[int(c)] for c in str(n))
+
+
+def report(input_zoo, met, self_met):
+
+    print ' ' + ' '.join(input_zoo)
+    for m, sm in zip(met, self_met):
+        print str(m) + spellout(sm)
+    print spellout(sum(met)) + '\n'
+
+
+# the zoo
+def creature(my_id, venue, my_lock_acquire, in_lock_acquire, out_lock_release):
+
+    while True:
+        my_lock_acquire()   # only proceed if not already at meeting place
+        in_lock_acquire()   # only proceed when holding in_lock
+        venue[0] = my_id    # register at meeting place
+        out_lock_release()  # signal "registration ok"
+
+
+def let_them_meet(meetings_left, input_zoo,
+                  compl=compl_dict, allocate=thread.allocate_lock):
+    # prepare
+    c_no = len(input_zoo)
+    venue = [-1]
+    met = [0] * c_no
+    self_met = [0] * c_no
+    colors = input_zoo[:]
+    
+    in_lock = allocate()
+    in_lock_acquire = in_lock.acquire     # function aliases
+    in_lock_release = in_lock.release     # (minor performance gain)
+    in_lock_acquire()
+    out_lock = allocate()
+    out_lock_release = out_lock.release
+    out_lock_acquire = out_lock.acquire
+    out_lock_acquire()
+    locks = [allocate() for c in input_zoo]
+    
+    # let creatures wild
+    for ci in xrange(c_no):
+        args = (ci, venue, locks[ci].acquire, in_lock_acquire, out_lock_release)
+        new = thread.start_new_thread(creature, args)
+    time.sleep(0.05)     # to reduce work-load imbalance
+    
+    in_lock_release()   # signal "meeting_place open for registration"
+    out_lock_acquire()  # only proceed with a "registration ok" signal
+    id1 = venue[0]
+    while meetings_left > 0:
+        in_lock_release()
+        out_lock_acquire()
+        id2 = venue[0]
+        if id1 != id2:
+            new_color = compl[(colors[id1], colors[id2])]
+            colors[id1] = new_color
+            colors[id2] = new_color
+            met[id1] += 1
+            met[id2] += 1
+        else:
+            self_met[id1] += 1
+            met[id1] += 1
+        meetings_left -= 1
+        if meetings_left > 0:
+            locks[id1].release()  # signal "you were kicked from meeting place"
+            id1 = id2
+        else:
+            report(input_zoo, met, self_met)
+
+           
+def chameneosiate(n):
+
+    check_complement()
+    let_them_meet(n, ['blue', 'red', 'yellow'])
+    let_them_meet(n, ['blue', 'red', 'yellow', 'red', 'yellow',
+                      'blue', 'red', 'yellow', 'red', 'blue'])
+    #print ''
+
+
+chameneosiate(int(sys.argv[1]))       

data/sources/python/dispatch.python

@@ -0,0 +1,176 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org/
+#
+# contributed by Kevin Carson
+import sys
+
+
+class IBottleState :
+    Empty = None
+    Full = None
+    Sealed = None
+
+
+class BottleState(IBottleState) :
+    def __init__(self) :
+        self.Empty = BottleState.EmptyState()
+        self.Full = BottleState.FullState()
+        self.Sealed = BottleState.SealedState()
+
+    def initialState(self) :
+        return self.Empty
+
+    class EmptyState :
+        def next(self) :
+            return IBottleState.Full
+
+        def tag(self) :
+            return 1
+
+    class FullState :
+        def next(self) :
+            return IBottleState.Sealed
+
+        def tag(self) :
+            return 2
+
+    class SealedState :
+        def next(self) :
+            return IBottleState.Empty
+
+        def tag(self) :
+            return 3
+
+
+class PressurizedBottleState(BottleState) :
+    def __init__(self, tag) :
+        BottleState.__init__(self)
+        self.UnpressurizedEmpty = UnpressurizedEmptyState()
+        self.UnpressurizedFull = UnpressurizedFullState()
+        self.PressurizedSealed = PressurizedSealedState()
+
+    def initialState(self) :
+        return self.UnpressurizedEmpty
+
+    class UnpressurizedEmptyState :
+        def next(self) :
+            return self.UnpressurizedFull
+
+        def tag(self) :
+            return 4
+
+    class UnpressurizedFullState :
+        def next(self) :
+            return self.PressurizedUnsealed
+
+        def tag(self) :
+            return 5
+
+    class PressurizedUnsealedState :
+        def next(self) :
+            return self.Sealed
+
+        def tag(self) :
+            return 6
+
+    class PressurizedSealedState :
+        def next(self) :
+            return self.UnpressurizedEmpty
+
+        def tag(self) :
+            return 7
+
+
+class Bottle :
+    def __init__(self, Id) :
+        self.Id = Id
+        self.state = BottleState()
+        self.state = self.state.initialState()
+
+    def state(self, state) :
+        self.state = state
+
+    def cycle(self) :
+        self.fill(), self.seal(), self.empty()
+
+    def initialState(self) :
+        return self.initialState()
+
+    def empty(self) :
+        self.state.next()
+
+    def fill(self) :
+        self.state.next()
+
+    def seal(self) :
+        self.state.next()
+
+    def check(self, c) :
+        return self.state.tag() + self.Id + c
+
+
+class PressurizedBottle(PressurizedBottleState, Bottle) :
+    def __init__(self, Id) :
+        Bottle.__init__(self, Id)
+
+    def initialState(self) :
+        return PressurizedBottleState.initialState()
+
+    def pressurize(self) :
+        self.state.next()
+
+    def cycle(self) :
+        self.fill(), self.pressurize(), self.seal(), self.empty()
+
+
+def bottleCheck(a1, a2, a3, a4, a5, i) :
+    a1.cycle()
+    a2.cycle()
+    a3.cycle()
+    a4.cycle()
+    a5.cycle()
+
+    r = i % 2
+
+    return a1.check(r) + a2.check(r) + a3.check(r) + a4.check(r) + a5.check(r)
+
+
+def main() :
+    n = int(sys.argv[1])
+
+    b1 = Bottle(1)
+    b2 = Bottle(2)
+    b3 = Bottle(3)
+    b4 = Bottle(4)
+    b5 = Bottle(5)
+    b6 = Bottle(6)
+    b7 = Bottle(7)
+    b8 = Bottle(8)
+    b9 = Bottle(9)
+    b0 = Bottle(0)
+
+    p1 = PressurizedBottle(1)
+    p2 = PressurizedBottle(2)
+    p3 = PressurizedBottle(3)
+    p4 = PressurizedBottle(4)
+    p5 = PressurizedBottle(5)
+    p6 = PressurizedBottle(6)
+    p7 = PressurizedBottle(7)
+    p8 = PressurizedBottle(8)
+    p9 = PressurizedBottle(9)
+    p0 = PressurizedBottle(0)
+
+    check = 0
+
+    for i in xrange(1, n + 1) :
+        check += bottleCheck(b1, b2, b3, b4, b5, i);
+        check += bottleCheck(b6, b7, b8, b9, b0, i);
+
+        check += bottleCheck(p1, p2, p3, p4, p5, i);
+        check -= bottleCheck(p6, p7, p8, p9, p0, i);
+    
+    print check
+
+
+main()

data/sources/python/dispatch.python-2.python

@@ -0,0 +1,136 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org/
+#
+# contributed by Antoine Pitrou
+
+import sys
+
+class BottleState(object):
+    pass
+
+class EmptyState(BottleState):
+    tag = 1
+
+    def do_next(self, target):
+        target.state = Full
+
+class FullState(BottleState):
+    tag = 2
+
+    def do_next(self, target):
+        target.state = Sealed
+
+class SealedState(BottleState):
+    tag = 3
+
+    def do_next(self, target):
+        target.state = Empty
+
+Empty = EmptyState()
+Full = FullState()
+Sealed = SealedState()
+BottleState.initial_state = Empty
+
+class PressurizedBottleState(BottleState):
+    pass
+
+class UnpressurizedEmptyState(PressurizedBottleState):
+    tag = 4
+
+    def do_next(self, target):
+        target.state = UnpressurizedFull
+
+class UnpressurizedFullState(PressurizedBottleState):
+    tag = 5
+
+    def do_next(self, target):
+        target.state = PressurizedUnsealed
+
+class PressurizedUnsealedState(PressurizedBottleState):
+    tag = 6
+
+    def do_next(self, target):
+        target.state = Sealed
+
+class PressurizedSealedState(PressurizedBottleState):
+    tag = 7
+
+    def do_next(self, target):
+        target.state = UnpressurizedEmpty
+
+UnpressurizedEmpty = UnpressurizedEmptyState()
+UnpressurizedFull = UnpressurizedFullState()
+PressurizedUnsealed = PressurizedUnsealedState()
+PressurizedSealed = PressurizedSealedState()
+PressurizedBottleState.initial_state = UnpressurizedEmpty
+
+
+class Bottle(object):
+    state_type = BottleState
+
+    def __init__(self, id_):
+        self.id_ = id_
+        self.state = self.state_type.initial_state
+
+    def fill(self):
+        self.state.do_next(self)
+
+    def seal(self):
+        self.state.do_next(self)
+
+    def empty(self):
+        self.state.do_next(self)
+        
+    def cycle(self):
+        self.fill()
+        self.seal()
+        self.empty()
+
+    def check(self, c):
+        return c + self.id_ + self.state.tag
+
+
+class PressurizedBottle(Bottle):
+    state_type = PressurizedBottleState
+
+    def __init__(self, *args, **kargs):
+        Bottle.__init__(self, *args, **kargs)
+
+    def pressurize(self):
+        self.state.do_next(self)
+
+    def cycle(self):
+        self.fill()
+        self.pressurize()
+        self.seal()
+        self.empty()
+
+
+def bottle_check(a1, a2, a3, a4, a5, i):
+    a1.cycle()
+    a2.cycle()
+    a3.cycle()
+    a4.cycle()
+    a5.cycle()
+    c = i % 2
+    return a1.check(c) + a2.check(c) + a3.check(c) + a4.check(c) + a5.check(c)
+
+def main():
+    n = int(sys.argv[1])
+    b0, b1, b2, b3, b4, b5, b6, b7, b8, b9 = [
+        Bottle(i) for i in range(10)]
+    p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 = [
+        PressurizedBottle(i) for i in range(10)]
+
+    check = 0
+    for i in xrange(1, n+1):
+        check += bottle_check(b1, b2, b3, b4, b5, i)
+        check += bottle_check(b6, b7, b8, b9, b0, i)
+        check += bottle_check(p1, p2, p3, p4, p5, i)
+        check -= bottle_check(p6, p7, p8, p9, p0, i)
+
+    print "%d" % check
+
+main()
+

data/sources/python/echo.python

@@ -0,0 +1,64 @@
+#!/usr/bin/python
+# $Id: echo.python,v 1.1.1.1 2004-05-19 18:09:37 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from Brad Knotwell
+
+import sys, os
+from socket import *
+
+DATA = "Hello there sailor\n"
+bufferSize = len(DATA)
+
+def server_sock():
+    sock = socket(AF_INET, SOCK_STREAM)
+    sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+    sock.bind(('127.0.0.1', 0));
+    sock.listen(2)
+    return(sock)
+
+def get_port(sock):
+    host, port = sock.getsockname()
+    return(port)
+
+def client_sock(port):
+    sock = socket(AF_INET, SOCK_STREAM)
+    sock.connect(('127.0.0.1', port))
+    return(sock)
+
+def echo_client(n, port):
+    sock = client_sock(port)
+    sender,receiver = sock.send,sock.recv
+    for i in range(0,n):
+        sender(DATA)
+        ans = receiver(bufferSize)
+        while ans[-1] != "\n":
+            ans += receiver(bufferSize - len(ans))
+        if ans <> DATA:
+            raise("client: \"%s\" ne \"%s\"" % (DATA, ans))
+    sock.close()
+
+def echo_server(n):
+    ssock = server_sock()
+    if os.fork() > 0:
+        # parent is server
+        csock, addr = ssock.accept()
+        n = 0
+        sender,receiver = csock.send,csock.recv
+        while 1:
+            dat = receiver(bufferSize)
+            if not dat: break
+            sender(dat)
+            n += len(dat)
+        print "server processed %d bytes" % n
+        os.wait()
+    else:
+        # child is client
+        echo_client(n, get_port(ssock))
+
+def main():
+    n = int(sys.argv[1])
+    if n < 1:
+        n = 1
+    echo_server(n)
+
+main()