chrislo-sourceclassifier 0.2.0

data/sources/python/reversefile.python

@@ -0,0 +1,13 @@
+#!/usr/bin/python
+# $Id: reversefile.python,v 1.1.1.1 2004-05-19 18:12:18 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# from Brad Knotwell
+# with help from Mark Baker
+
+def main():
+    from sys import stdin, stdout
+    w = stdin.readlines()
+    w.reverse()
+    stdout.writelines(w)
+
+main()

data/sources/python/sieve.python

@@ -0,0 +1,50 @@
+#!/usr/bin/python 
+# $Id: sieve.python,v 1.4 2004-08-05 07:07:03 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+# with help from Brad Knotwell
+
+#uncomment for psyco JIT
+#import psyco
+#psyco.full()
+
+import sys
+
+def main():
+    try:
+        NUM = int(sys.argv[1])
+    except:
+        NUM = 1
+
+    for foo in xrange(0,NUM):
+        count = 0
+        flags = (8193) * [1]
+        for i in xrange(2,8193):
+            if flags[i]:
+                # remove all multiples of prime: i
+                k = i + i
+                while k < 8193:
+                    flags[k] = 0
+                    k = k + i
+                count += 1    
+    print "Count:", count
+    #uncomment to verify the algorithm
+    #n = 0
+    #for i in range(200):
+    #    if flags[i]:
+    #        print n
+    #    n += 1
+
+main()
+
+
+
+
+
+
+
+
+
+
+
+
+

data/sources/python/spectralnorm.python-2.python

@@ -0,0 +1,36 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# Contributed by Sebastien Loisel
+# Fixed by Isaac Gouy
+# Sped up by Josh Goldfoot
+
+import math, sys, itertools
+
+def eval_A(i,j):
+    return 1.0/((i+j)*(i+j+1)/2+i+1)
+
+def eval_A_times_u(u):
+    return [sum(eval_A(i,j)*u[j] for j in xrange(len(u)))
+            for i in xrange(len(u))]
+
+def eval_At_times_u(u):
+    return [sum(eval_A(j,i)*u[j] for j in xrange(len(u)))
+            for i in xrange(len(u))]
+
+def eval_AtA_times_u(u):
+    return eval_At_times_u(eval_A_times_u(u))
+
+def main():
+    n = int(sys.argv[1])
+    u = [1]*n
+    for i in xrange(10):
+        v=eval_AtA_times_u(u)
+        u=eval_AtA_times_u(v)
+    vBv = vv = 0
+    for ue, ve in itertools.izip(u,v):
+        vBv += ue * ve
+        vv += ve * ve
+    print "%0.9f" % (math.sqrt(vBv/vv))
+
+main()

data/sources/python/spellcheck.python

@@ -0,0 +1,17 @@
+#!/usr/bin/python
+# $Id: spellcheck.python,v 1.2 2005-02-19 17:05:39 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+#
+# From Tupteq, based on original code by Fred Bremmer
+
+import sys
+
+def main():
+    dict = set(line[:-1] for line in file("Usr.Dict.Words") if line != '\n')
+
+    for line in sys.stdin:
+        word = line[:-1]
+        if word and word not in dict:
+	    print word
+
+main()

data/sources/python/strcat.python

@@ -0,0 +1,35 @@
+#!/usr/bin/python
+# $Id: strcat.python,v 1.3 2004-08-04 07:40:02 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+import sys
+
+# Illegal version:  From Chris Rebert
+#def main():
+#    print "".join(["hello" for i in xrange(int(sys.argv[1])-1)])
+
+##################################################################
+# Other options
+##################################################################
+# from Brad Knotwell, with changes based on recommendations from
+#   Andrew Bennetts
+import sys,cStringIO
+def main():
+    str = cStringIO.StringIO()
+    strwrite = str.write
+    for i in xrange(0,int(sys.argv[1])):
+        strwrite('hello\n')
+
+    print str.tell()
+
+##################################################################
+# This version uses the native string concatenation operator "+"
+#
+#import sys
+#def main():
+#    n = int(sys.argv[1])
+#    str = ""
+#    for i in xrange(0,n):
+#        str = str + "hello\n"
+#    print len(str)
+
+main()

data/sources/python/takfp.python

@@ -0,0 +1,19 @@
+
+
+import sys
+
+
+def takfp(x, y, z):
+    if y >= x:
+        return z
+    return takfp(takfp(x - 1.0, y, z), takfp(y - 1.0, z, x), takfp(z - 1.0, x, y))
+
+def main():
+    try:
+        n = float(sys.argv[1])
+    except:
+        print "Usage: %s <N>" % sys.argv[0]
+
+    print takfp(n * 3.0, n * 2.0, n * 1.0)
+
+main()

data/sources/python/tcpecho.python

@@ -0,0 +1,67 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org
+#
+# Contributed by Kevin Carson
+
+from sys import argv, stdout
+from socket import socket, gethostbyname, \
+    AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
+from os import fork, wait, _exit
+
+
+def server(msg_count, msg_mult, reply_size, request_size) :
+    s = socket(AF_INET, SOCK_STREAM)
+    s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+    s.bind((gethostbyname('localhost'), 11000))
+    s.listen(1)
+    sc, addr = s.accept()
+    reply = " " * reply_size
+    screcv = sc.recv
+    scsendall = sc.sendall
+
+    for i in xrange(msg_count * msg_mult) :
+        request = screcv(request_size)
+        scsendall(reply)
+
+    sc.close()
+    s.close()
+
+
+def client(msg_count, msg_mult, reply_size, request_size) :
+    s = socket(AF_INET, SOCK_STREAM)
+    while s.connect_ex((gethostbyname('localhost'), 11000)) != 0 : pass
+    request = " " * request_size
+    srecv = s.recv
+    ssend = s.send
+
+    replies = bytes = 0
+    for i in xrange(msg_count * msg_mult) :
+        ssend(request)
+        byte_count = 0
+        while byte_count < reply_size :
+            reply = srecv(reply_size)
+            byte_count += len(reply)
+        bytes += byte_count
+        replies += 1
+
+    s.close()
+    print "replies: %d\tbytes: %d" % (replies, bytes)
+    stdout.flush()
+
+
+M = 6400
+reply_size = 64
+request_size = 64
+
+N = int(argv[1])
+
+child_pid = fork()
+
+if child_pid == 0 :
+    client(N, M, reply_size, request_size)
+    _exit(0)
+
+else :
+    server(N, M, reply_size, request_size)
+    wait()

data/sources/python/tcprequest.python

@@ -0,0 +1,67 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org
+#
+# Contributed by Kevin Carson
+
+from sys import argv, stdout
+from socket import socket, gethostbyname, \
+    AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
+from os import fork, wait, _exit
+
+
+def server(msg_count, msg_mult, reply_size, request_size) :
+    s = socket(AF_INET, SOCK_STREAM)
+    s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+    s.bind((gethostbyname('localhost'), 11000))
+    s.listen(1)
+    sc, addr = s.accept()
+    reply = " " * reply_size
+    screcv = sc.recv
+    scsendall = sc.sendall
+
+    for i in xrange(msg_count * msg_mult) :
+        request = screcv(request_size)
+        scsendall(reply)
+
+    sc.close()
+    s.close()
+
+
+def client(msg_count, msg_mult, reply_size, request_size) :
+    s = socket(AF_INET, SOCK_STREAM)
+    while s.connect_ex((gethostbyname('localhost'), 11000)) != 0 : pass
+    request = " " * request_size
+    srecv = s.recv
+    ssend = s.send
+
+    replies = bytes = 0
+    for i in xrange(msg_count * msg_mult) :
+        ssend(request)
+        byte_count = 0
+        while byte_count < reply_size :
+            reply = srecv(reply_size)
+            byte_count += len(reply)
+        bytes += byte_count
+        replies += 1
+
+    s.close()
+    print "replies: %d\tbytes: %d" % (replies, bytes)
+    stdout.flush()
+        
+
+M = 100
+reply_size = 4096
+request_size = 64
+
+N = int(argv[1])
+
+child_pid = fork()
+
+if child_pid == 0 :
+    client(N, M, reply_size, request_size)
+    _exit(0)
+
+else :
+    server(N, M, reply_size, request_size)
+    wait()

data/sources/python/tcpstream.python

@@ -0,0 +1,67 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org
+#
+# Contributed by Kevin Carson
+
+from sys import argv, stdout
+from socket import socket, gethostbyname, \
+    AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
+from os import fork, wait, _exit
+
+
+def server(msg_count, msg_mult, reply_size, request_size) :
+    s = socket(AF_INET, SOCK_STREAM)
+    s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+    s.bind((gethostbyname('localhost'), 11000))
+    s.listen(1)
+    sc, addr = s.accept()
+    reply = " " * reply_size
+    screcv = sc.recv
+    scsendall = sc.sendall
+
+    for i in xrange(msg_count * msg_mult) :
+        request = screcv(request_size)
+        scsendall(reply)
+
+    sc.close()
+    s.close()
+
+
+def client(msg_count, msg_mult, reply_size, request_size) :
+    s = socket(AF_INET, SOCK_STREAM)
+    while s.connect_ex((gethostbyname('localhost'), 11000)) != 0 : pass
+    request = " " * request_size
+    srecv = s.recv
+    ssend = s.send
+
+    replies = bytes = 0
+    for i in xrange(msg_count * msg_mult) :
+        ssend(request)
+        byte_count = 0
+        while byte_count < reply_size :
+            reply = srecv(reply_size)
+            byte_count += len(reply)
+        bytes += byte_count
+        replies += 1
+
+    s.close()
+    print "replies: %d\tbytes: %d" % (replies, bytes)
+    stdout.flush()
+        
+
+M = 1
+reply_size = 409600
+request_size = 64
+
+N = int(argv[1])
+
+child_pid = fork()
+
+if child_pid == 0 :
+    client(N, M, reply_size, request_size)
+    _exit(0)
+
+else :
+    server(N, M, reply_size, request_size)
+    wait()

data/sources/python/threadring.python

@@ -0,0 +1,47 @@
+"""
+The Computer Language Benchmarks Game
+http://shootout.alioth.debian.org/
+Contributed by Antti Kervinen
+"""
+
+THREADS = 503
+
+# Uses pthread library on Linux
+import thread
+import sys
+
+# Set minimum stack size for threads, otherwise the program may fail
+# to create such a many threads
+thread.stack_size(32*1024)
+
+def threadfun(my_number, my_lock, next_lock):
+    global N, main_thread_lock
+    while 1:
+        my_lock.acquire()
+        if N == 0:
+            print my_number
+            main_thread_lock.release()
+        else:
+            N -= 1
+            next_lock.release()
+
+# main
+N = int(sys.argv[1])
+main_thread_lock = thread.allocate_lock()
+main_thread_lock.acquire()
+
+first_lock = thread.allocate_lock()
+next_lock = first_lock
+
+for number in xrange(THREADS):
+    this_lock = next_lock
+    this_lock.acquire()
+    if number == THREADS - 1:
+        next_lock = first_lock
+    else:
+        next_lock = thread.allocate_lock()
+    thread.start_new_thread(threadfun, 
+                            (number + 1, this_lock, next_lock))
+
+first_lock.release()
+main_thread_lock.acquire()