chrislo-sourceclassifier 0.2.0 → 0.2.1

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

@@ -1,122 +0,0 @@
-# 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

@@ -1,176 +0,0 @@
-#!/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

@@ -1,136 +0,0 @@
-#!/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

@@ -1,64 +0,0 @@
-#!/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()