chrislo-sourceclassifier 0.2.0

data/sources/python/prodcons.python

@@ -0,0 +1,51 @@
+#!/usr/bin/python
+# $Id: prodcons.python,v 1.1.1.1 2004-05-19 18:11:10 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+import sys
+from threading import * 
+
+access = Condition()
+count = 0
+consumed = 0
+produced = 0
+data = 0
+
+def consumer(n):
+    global count, data, consumed
+    while 1:
+        access.acquire()
+        while count == 0:
+            access.wait()
+        i = data
+        count = 0
+        access.notify()
+        access.release()
+        consumed += 1
+        if i == n:
+            break
+
+def producer(n):
+    global count, data, produced
+    for i in xrange(1,n+1):
+        access.acquire()
+        while count == 1:
+            access.wait()
+        data = i
+        count = 1
+        access.notify()
+        access.release()
+        produced += 1
+
+def main(n):
+    t1 = Thread(target=producer, args=(n,))
+    t2 = Thread(target=consumer, args=(n,))
+    t1.start()
+    t2.start()
+    t1.join()
+    t2.join()
+    print produced, consumed
+    
+main(int(sys.argv[1]))
+
+

data/sources/python/random.python

@@ -0,0 +1,27 @@
+#!/usr/bin/python
+# $Id: random.python,v 1.1.1.1 2004-05-19 18:11:16 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from Brent Burley
+
+import sys
+
+IM = 139968
+IA = 3877
+IC = 29573
+
+LAST = 42
+def gen_random(max):
+    global LAST
+    LAST = (LAST * IA + IC) % IM
+    return( (max * LAST) / IM )
+
+def main():
+    N = int(sys.argv[1])
+    if N < 1:
+        N = 1
+    gr = gen_random
+    for i in xrange(1,N):
+        gr(100.0)
+    print "%.9f" % gr(100.0)
+
+main()

data/sources/python/raytracer.python

@@ -0,0 +1,203 @@
+#!/usr/bin/python -OO
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org/
+#
+# contributed by Kevin Carson
+
+import sys
+from math import sqrt
+
+
+rn_coefficient = 3.0 / sqrt(12)
+delta = sqrt(2.220446e-16)
+infinity = 1.797693e+308
+
+
+class Vector :
+    def __init__(self, x, y, z) :
+        self.x = x
+        self.y = y
+        self.z = z
+
+    def __add__(self, v) :
+        return Vector(self.x + v.x, self.y + v.y, self.z + v.z)
+
+    def __sub__(self, v) :
+        return Vector(self.x - v.x, self.y - v.y, self.z - v.z)
+
+    def __rmul__(self, n) :
+        return Vector(self.x * n, self.y * n, self.z * n)
+
+    def dot(self, v) :
+        return self.x * v.x + self.y * v.y + self.z * v.z
+
+    def unitise(self) :
+        return (1 / sqrt(self.dot(self))) * self
+
+
+class Ray :
+    def __init__(self, o, d) :
+        self.origin = o
+        self.direction = d
+
+
+class Scene :
+    def __init__(self) :
+        pass
+
+    def intersect(self, point, vector, ray) :
+        return 0.0, vector
+
+    def delete(self) :
+        if type(self) == Group :
+            for i in self.obs :
+                self.objs[i].delete()
+                self.objs[i] = None
+            self = None
+
+
+class Sphere(Scene) :
+    def __init__(self, center, radius) :
+        Scene.__init__(self)
+        self.center = center
+        self.radius = radius
+
+    def ray_sphere(self, ray) :
+        v = self.center - ray.origin
+        b = v.dot(ray.direction)
+        disc = b * b - v.dot(v) + self.radius * self.radius
+
+        if disc < 0.0 :
+            return infinity
+
+        d = sqrt(disc)
+        t2 = b + d
+
+        if t2 < 0.0 :
+            return infinity
+
+        t1 = b - d
+
+        if t1 > 0.0 :
+            return t1
+
+        else :
+            return t2
+
+
+    def intersect(self, pt, normal, ray) :
+        l = self.ray_sphere(ray)
+
+        if l >= pt :
+            return pt, normal
+
+        normal = (ray.origin + l * ray.direction - self.center).unitise()
+        return l, normal
+
+
+class Group(Scene) :
+    def __init__(self, b) :
+        Scene.__init__(self)
+        self.bound = b
+        self.objs = []
+
+    def intersect(self, pt, normal, ray) :
+        l = self.bound.ray_sphere(ray)
+        
+        if l >= pt :
+            return pt, normal
+
+        for obj in self.objs :
+            pt, normal = obj.intersect(pt, normal, ray)
+
+        return pt, normal
+    
+
+def ray_trace(light, ray, scene) :
+    l = infinity
+    normal = Vector(0.0, 0.0, 0.0)
+    l, normal = scene.intersect(l, normal, ray)
+
+    if l == infinity :
+        return 0.0
+
+    o = ray.origin + l * ray.direction + delta * normal
+    g = -normal.dot(light)
+    l = infinity
+
+    if g <= 0.0 :
+        return 0.0
+
+    l, normal = scene.intersect(
+        l,
+        normal,
+        Ray(o, Vector(0.0, 0.0, 0.0) - light)
+    )
+
+    if l == infinity :
+        return g
+
+    else :
+        return 0.0
+
+
+def create(level, r, x, y, z) :
+    sphere = Sphere(Vector(x, y, z), r)
+
+    if level == 1 :
+        return sphere
+
+    group = Group(Sphere(Vector(x, y, z), 3.0 * r))
+    group.objs.append(sphere)
+
+    rn = rn_coefficient * r
+
+    for dz in xrange(-1, 2, 2) :
+        for dx in xrange(-1, 2, 2) :
+            group.objs.append(
+                create(level - 1, r / 2.0, x - dx * rn, y + rn, z - dz * rn)
+            )
+
+    return group
+
+
+def main() :
+    if len(sys.argv) == 2 :
+        n = int(sys.argv[1])
+        
+    else :
+        n = 256
+
+    level = 6
+    scene = create(level, 1.0, 0.0, -1.0, 0.0)
+
+    ss = 4
+    ss2 = ss * ss
+
+    cout = sys.stdout.write
+
+    cout("P5\n%d %d\n255\n" % (n, n))
+
+    for y in xrange(n - 1, -1, -1) :
+        for x in xrange(n) :
+            g = 0.0
+            for dx in xrange(ss) :
+                for dy in xrange(ss) :
+                    g += ray_trace(
+                        Vector(-1.0, -3.0, 2.0).unitise(),
+                        Ray(
+                            Vector(0.0, 0.0, -4.0),
+                            Vector(
+                                x + dx / float(ss) - n / 2.0,
+                                y + dy / float(ss) - n / 2.0,
+                                float(n)
+                            ).unitise()
+                        ),
+                        scene
+                    )
+            g = 0.5 + 255 * g / ss2
+            cout(chr(int(g)))
+    scene.delete()
+
+
+main()

data/sources/python/recursive.python

@@ -0,0 +1,35 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+# based on bearophile's psyco program
+# slightly modified by Isaac Gouy
+
+def Ack(x, y):
+    if x == 0: return y+1
+    if y == 0: return Ack(x-1, 1)
+    return Ack(x-1, Ack(x, y-1))
+
+def Fib(n):
+    if n < 2: return 1
+    return Fib(n-2) + Fib(n-1)
+
+def FibFP(n):
+    if n < 2.0: return 1.0
+    return FibFP(n-2.0) + FibFP(n-1.0)
+
+def Tak(x, y, z):
+    if y < x: return Tak( Tak(x-1,y,z), Tak(y-1,z,x), Tak(z-1,x,y) )
+    return z
+
+def TakFP(x, y, z):
+    if y < x: return TakFP( TakFP(x-1.0,y,z), TakFP(y-1.0,z,x), TakFP(z-1.0,x,y) )
+    return z
+
+from sys import argv, setrecursionlimit
+setrecursionlimit(20000)
+
+n = int(argv[1]) - 1
+print "Ack(3,%d):" % (n+1), Ack(3, n+1)
+print "Fib(%.1f): %.1f" % (28.0+n, FibFP(28.0+n))
+print "Tak(%d,%d,%d): %d" % (3*n, 2*n, n, Tak(3*n, 2*n, n))
+print "Fib(3):", Fib(3)
+print "Tak(3.0,2.0,1.0):", TakFP(3.0, 2.0, 1.0)

data/sources/python/regexdna.python

@@ -0,0 +1,39 @@
+#The Great Computer Language Shootout
+#http://shootout.alioth.debian.org/
+#contributed by Dominique Wahli
+
+from sys import stdin
+from re import sub, findall
+
+seq = stdin.read()
+ilen = len(seq)
+
+seq = sub('(>.*\n)|(\n)', '', seq)
+clen = len(seq)
+
+variants = (
+      'agggtaaa|tttaccct',
+      '[cgt]gggtaaa|tttaccc[acg]',
+      'a[act]ggtaaa|tttacc[agt]t',
+      'ag[act]gtaaa|tttac[agt]ct',
+      'agg[act]taaa|ttta[agt]cct',
+      'aggg[acg]aaa|ttt[cgt]ccct',
+      'agggt[cgt]aa|tt[acg]accct',
+      'agggta[cgt]a|t[acg]taccct',
+      'agggtaa[cgt]|[acg]ttaccct')
+for f in variants:
+    print f, len(findall(f, seq))
+
+subst = {
+      'B' : '(c|g|t)', 'D' : '(a|g|t)',   'H' : '(a|c|t)', 'K' : '(g|t)',
+      'M' : '(a|c)',   'N' : '(a|c|g|t)', 'R' : '(a|g)',   'S' : '(c|g)',
+      'V' : '(a|c|g)', 'W' : '(a|t)',     'Y' : '(c|t)'}
+for f, r in subst.items(): 
+    seq = sub(f, r, seq)
+
+print
+print ilen
+print clen
+print len(seq)
+
+

data/sources/python/regexdna.python-2.python

@@ -0,0 +1,34 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# contributed by Dominique Wahli
+# modified by Heinrich Acker
+
+import sys, re
+
+seq = sys.stdin.read()
+ilen = len(seq)
+
+seq = re.sub('>.*', '', seq)
+seq = re.sub('\n', '', seq)
+
+for f in ('agggtaaa|tttaccct',
+      '[cgt]gggtaaa|tttaccc[acg]',
+      'a[act]ggtaaa|tttacc[agt]t',
+      'ag[act]gtaaa|tttac[agt]ct',
+      'agg[act]taaa|ttta[agt]cct',
+      'aggg[acg]aaa|ttt[cgt]ccct',
+      'agggt[cgt]aa|tt[acg]accct',
+      'agggta[cgt]a|t[acg]taccct',
+      'agggtaa[cgt]|[acg]ttaccct'):
+    s, r = f.split('|')
+    print f, len(re.findall(s, seq)+re.findall(r, seq))
+
+print
+print ilen
+print len(seq)
+
+for f, r in zip('BDHKMNRSVWY',('(c|g|t)', '(a|g|t)', '(a|c|t)', '(g|t)',
+      '(a|c)', '(a|c|g|t)', '(a|g)', '(c|g)', '(a|c|g)', '(a|t)', '(c|t)')):
+    seq = re.sub(f, r, seq)
+
+print len(seq)

data/sources/python/regexmatch.python

@@ -0,0 +1,36 @@
+#!/usr/pkg/bin/python
+# $Id: regexmatch.python,v 1.1.1.1 2004-05-19 18:11:27 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+import sys, re
+
+def main():
+    NUM = int(sys.argv[1])
+    if NUM < 1:
+        NUM = 1
+
+    phones = sys.stdin.readlines()
+
+    rx = re.compile(
+        r'(?:^|[^\d\(])'
+        r'(?:\((\d\d\d)\)|(\d\d\d))'
+        r'[ ]'
+        r'(\d\d\d)'
+        r'[ -]'
+        r'(\d\d\d\d)'
+        r'\D'
+        )
+
+    findIt = rx.search
+    count = 0
+    for i in xrange(0,NUM):
+        for line in phones:
+            m = findIt(line)
+            if m:
+                g = m.group
+                num = "(" + (g(1) or g(2)) + ") " + g(3) + "-" + g(4)
+                if 0 == i:
+                    count = count + 1
+                    print "%d: %s" % (count, num)
+
+main()

data/sources/python/revcomp.python-3.python

@@ -0,0 +1,31 @@
+#!/usr/bin/python
+# 
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+# 
+# contributed by Jacob Lee, Steven Bethard, et al
+
+import sys, string
+
+def show(seq, 
+         table=string.maketrans('ACBDGHK\nMNSRUTWVYacbdghkmnsrutwvy',
+                                'TGVHCDM\nKNSYAAWBRTGVHCDMKNSYAAWBR')):
+                                
+   seq = (''.join(seq)).translate(table)[::-1]
+   for i in xrange(0, len(seq), 60):
+      print seq[i:i+60]
+      
+
+def main():
+   seq = []
+   add_line = seq.append
+   for line in sys.stdin:
+      if line[0] in '>;':
+         show(seq)
+         print line,
+         del seq[:]
+      else:
+         add_line(line[:-1])
+   show(seq)
+
+main()