chrislo-sourceclassifier 0.2.0

data/sources/python/knucleotide.python

@@ -0,0 +1,55 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# submitted by Ian Osgood
+# modified by Sokolov Yura
+# modified by bearophile
+
+from sys import stdin
+
+def gen_freq(seq, frame, frequences):
+    ns = len(seq) + 1 - frame
+    frequences.clear()
+    for ii in xrange(ns):
+        nucleo = seq[ii:ii + frame]
+        if nucleo in frequences:
+            frequences[nucleo] += 1
+        else:
+            frequences[nucleo] = 1
+    return ns, frequences
+
+
+def sort_seq(seq, length, frequences):
+    n, frequences = gen_freq(seq, length, frequences)
+
+    l = sorted(frequences.items(), reverse=True, key=lambda (seq,freq): (freq,seq))
+
+    print '\n'.join("%s %.3f" % (st, 100.0*fr/n) for st,fr in l)
+    print
+
+
+def find_seq(seq, s, frequences):
+    n,t = gen_freq(seq, len(s), frequences)
+    print "%d\t%s" % (t.get(s, 0), s)
+
+
+def main():
+    frequences = {}
+    for line in stdin:
+        if line[0:3] == ">TH":
+            break
+
+    seq = []
+    for line in stdin:
+        if line[0] in ">;":
+            break
+        seq.append( line[:-1] )
+    sequence = "".join(seq).upper()
+
+    for nl in 1,2:
+        sort_seq(sequence, nl, frequences)
+
+    for se in "GGT GGTA GGTATT GGTATTTTAATT GGTATTTTAATTTATAGT".split():
+        find_seq(sequence, se, frequences)
+
+main()

data/sources/python/lists.python

@@ -0,0 +1,44 @@
+#!/usr/bin/python
+# $Id: lists.python,v 1.1.1.1 2004-05-19 18:10:24 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with improvements from Mark Baker
+
+import sys
+
+SIZE = 10000
+
+def test_lists():
+    Li1 = range(1, SIZE + 1)
+    Li2 = Li1[:]
+    Li3 = []
+
+    # remove each individual item from left side of Li2 and
+    # append to right side of Li3 (preserving order)
+    # 
+    # popping the first element is *expensive*
+    #
+    #while Li2:
+    #    Li3.append(Li2.pop(0))   
+    Li2.reverse()
+    while Li2:
+        Li3.append(Li2.pop())
+    while Li3:
+        Li2.append(Li3.pop())
+    Li1.reverse()
+    if Li1[0] != SIZE:
+        return 0
+    if Li1 == Li2:
+        return len(Li1)
+    else:
+        return 0
+
+def main():
+    NUM = int(sys.argv[1])
+    if NUM < 1:
+        NUM = 1
+    while NUM > 0:
+        result = test_lists()
+        NUM = NUM - 1
+    print result
+
+main()

data/sources/python/magicsquares.python

@@ -0,0 +1,145 @@
+#!/usr/bin/python
+##   The Computer Language Shootout
+##   http://shootout.alioth.debian.org/
+##
+##   benchmark implementation (not optimized)
+##   contributed by Josh Goldfoot
+
+import sys
+import Queue
+import bisect
+
+n = mn = 0
+
+class PriorityQueue(Queue.Queue):
+    def _init(self, maxsize):
+        self.maxsize = maxsize
+        self.queue = [] 
+    def _put(self, item):
+        bisect.insort(self.queue, item)
+    def _get(self):
+        return self.queue.pop(0) 
+
+class square(object):
+    __slots__ = ['grid', 'ffm', '__priority']
+    def __init__(self):
+        self.grid = [0 for i in xrange(n * n)]
+        self.ffm = None
+        self.__priority = None
+    def copy(self):
+        ret = square()
+        ret.grid[:] = self.grid
+        return ret
+    def gridRow(self, y):
+        return [ self.grid[x + y * n] for x in xrange(n)]
+    def gridCol(self, x):
+        return [ self.grid[x + y * n] for y in xrange(n)]
+    def __str__(self):
+        return "\n".join( [" ".join([str(self.grid[x + y * n])
+                    for x in xrange(n)]) for y in xrange(n)])
+    def possibleMoves(self, x,y):
+##Return all moves that can go in the cell x,y for a given
+##grid.  A move is possible if the move (number) is not already
+##in the grid, and if, after making that move, it is still possible to
+##satisfy the magic square conditions (all rows, columns, diagonals adding
+##up to mn, the magic number)
+        if self.grid[x + y * n] != 0:
+            return []
+        cellGroups = [self.gridRow(y), self.gridCol(x)]
+        if x == y:
+            cellGroups.append([ self.grid[i + i * n] for i in xrange(n) ])
+        if x + y == n - 1:
+            cellGroups.append([ self.grid[i + (n - 1 - i) * n] for i in xrange(n) ])
+        usedNumbers = set(self.grid)
+        onePossible = set()
+        for g in cellGroups:
+            if g.count(0) == 1:
+                onePossible.add(mn - sum(g))
+        if len(onePossible) == 1:
+            onlyPossibleMove = onePossible.pop()
+            if 1 <= onlyPossibleMove <= n*n and onlyPossibleMove not in usedNumbers:
+                return [onlyPossibleMove]
+            else:
+                return []
+        elif len(onePossible) > 1:
+            return []
+        highestCandidates = [mn - sum(g) for g in cellGroups]
+        highestCandidates.append(n * n)
+        highest = min(highestCandidates)
+        return [ i for i in xrange(highest + 1) if i not in usedNumbers ]
+    def findFewestMoves(self):
+##Go through the grid (starting at the top-left, and moving
+##right and down), checking all 0 cells to find the cell with the fewest
+##possible moves.
+        if self.ffm:
+            return self.ffm
+        minSoFar = []
+        minX = minY = None
+        minLenSoFar = 0
+        for y in xrange(n):
+            for x in xrange(n):
+                ind = x + y * n
+                if self.grid[ind] == 0:
+                    pm = self.possibleMoves(x,y)
+                    if minX == None or len(pm) < minLenSoFar:
+                        minSoFar[:] = pm
+                        minLenSoFar = len(pm)
+                        minX = x
+                        minY = y
+        self.ffm = (minSoFar, minLenSoFar, minX, minY)
+        return self.ffm
+        return (minSoFar, minLenSoFar, minX, minY)
+    
+    def successorNodes(self):
+##successorNodes: Find the cell with the fewest
+##possible moves left, and then creates a new node for each possible move
+##in that cell.  
+        (pm, len_pm, x, y) = self.findFewestMoves()
+        node = self.copy()  # Create a copy of yourself
+        ind = x + y * n
+        for move in pm:
+            node.grid[ind] = move
+            yield node
+    def priority(self):
+##The priority function is:
+##(number of zeros in the grid) plus
+##(number of possible moves in the cell with the fewest possible moves)
+##the lower the priority, the sooner the node will be popped from the queue.
+        if self.__priority == None:
+            (pm, len_pm, x, y) = self.findFewestMoves()
+            self.__priority = self.grid.count(0) + len_pm
+        return self.__priority
+    def __cmp__(self, other):
+##The priority queue is sorted first by
+##the node's calculated priority; then, if the priorities
+##are equal, by whichever node has the lowest numbers
+##in the top-left of the array (or the next cell over,
+##and so on).
+        c = cmp(self.priority(), other.priority())
+        if c == 0:
+            i = 0
+            while c == 0 and i < n * n:
+                c = cmp(self.grid[i], other.grid[i])
+                i += 1
+        return c
+
+def main():
+    global n, mn
+    n = len(sys.argv) > 1 and int(sys.argv[1]) or 3
+    mn = n * (1 + n * n) / 2
+    # Initialize priority queue and push a square full of zeros on it
+    priorityQueue = PriorityQueue()
+    priorityQueue.put( square() )
+    # Loop through the priority queue...
+    while not priorityQueue.empty():
+        node = priorityQueue.get()
+        # if priority is 0, then this is a complete square; stop
+        if node.priority() == 0:
+            break
+        # otherwise, add to the queue all squares that can be derived by filling in
+        #  one cell in this magic square
+        for newnode in node.successorNodes():
+            priorityQueue.put(newnode.copy() )
+    if node.priority() == 0:
+        print node
+main()

data/sources/python/mandelbrot.python

@@ -0,0 +1,44 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Tupteq
+
+import sys
+
+def main():
+    cout = sys.stdout.write
+    size = int(sys.argv[1])
+    xr_size = xrange(size)
+    xr_iter = xrange(50)
+    bit = 128
+    byte_acc = 0
+
+    cout("P4\n%d %d\n" % (size, size))
+
+    size = float(size)
+    for y in xr_size:
+        fy = 2j * y / size - 1j
+        for x in xr_size:
+            z = 0j
+            c = 2. * x / size - 1.5 + fy
+
+            for i in xr_iter:
+                z = z * z + c
+                if abs(z) >= 2.0:
+                    break
+            else:
+                byte_acc += bit
+
+            if bit > 1:
+                bit >>= 1
+            else:
+                cout(chr(byte_acc))
+                bit = 128
+                byte_acc = 0
+
+        if bit != 128:
+            cout(chr(byte_acc))
+            bit = 128
+            byte_acc = 0
+
+main()

data/sources/python/mandelbrot.python-2.python

@@ -0,0 +1,35 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Heinrich Acker
+
+import sys
+import numpy
+
+limit = 2.
+size = int(sys.argv[1])
+
+# create an array of NxN complex constants
+grid = numpy.arange(0, 2, 2./size)
+c = (grid-1.5).reshape(1, size).repeat(size, 0) + \
+     1j*(grid-1).reshape(size, 1).repeat(size, 1)
+
+# create NxN arrays for iteration and results
+z = 0*c
+mask = z==0
+
+# compute the mandelbrot set vectorized
+for i in range(50):
+    z = mask * (z * z + c)
+    mask = numpy.logical_and(mask, numpy.abs(z)<limit)
+
+# map the bool results to their binary value
+mask = mask.reshape(-1, 8).astype('uint8')
+for bit in range(8):
+    mask[:, 7-bit] *= 1 << bit
+
+# pack the results into bytes
+mask = mask.sum(1, 'uint8')
+
+# write image data
+sys.stdout.write("P4\n%d %d\n%s" % (size, size, mask.tostring()))

data/sources/python/mandelbrot.python-3.python

@@ -0,0 +1,46 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Tupteq
+
+import sys
+
+def main():
+    cout = sys.stdout.write
+    iter = 50
+    limit = 2.
+    size = int(sys.argv[1])
+    fsize = float(size)
+    xr_size = xrange(size)
+    xr_iter = xrange(iter)
+    bit_num = 7
+    byte_acc = 0
+
+    cout("P4\n%d %d\n" % (size, size))
+
+    for y in xr_size:
+        fy = 2j * y / fsize - 1j
+        for x in xr_size:
+            z = 0j
+            c = 2. * x / fsize - 1.5 + fy
+
+            for i in xr_iter:
+                z = z * z + c
+                if abs(z) >= limit:
+                    break
+            else:
+                byte_acc += 1 << bit_num
+
+            if bit_num == 0:
+                cout(chr(byte_acc))
+                bit_num = 7
+                byte_acc = 0
+            else:
+                bit_num -= 1
+
+        if bit_num != 7:
+            cout(chr(byte_acc))
+            bit_num = 7
+            byte_acc = 0
+
+main()

data/sources/python/matrix.python

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+#
+#
+# Author: �smund �deg�rd
+#         Simula Research Laboratory (2004)
+#
+#         modeled after the original matrix.py at the shootout.
+
+import sys
+from numarray import *
+
+size = 30
+
+def mkmatrix(rows,cols):
+    m = array([[i+(j-1)*rows for i in xrange(1,rows+1)] for j in xrange(1,cols+1)])
+    return m
+
+
+def mmult(m1,m2):
+    return dot(m1,m2)
+
+
+def main():
+    try: iter = int(sys.argv[1])
+    except: iter = 1
+
+    m1 = mkmatrix(size,size)
+    m2 = mkmatrix(size,size)
+    for i in xrange(iter):
+        mm = mmult(m1,m2)
+    print mm[0,0], mm[2,3], mm[3,2], mm[4,4]
+
+main()
+

data/sources/python/matrix.python-2.python

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# $Id: matrix.python-2.python,v 1.1 2004-11-10 06:47:57 bfulgham Exp $
+# from Kevin Turner
+# this example uses NumPy:
+# Numeric Python is available at http://www.pfdubois.com/numpy/
+
+import sys
+from Numeric import *
+
+size = 30
+
+def main():
+    iter = int(sys.argv[1])
+
+    # Create an array of size*size consecutive numbers (starting at 1,
+    # not 0), and reshape it into a (size, size) matrix.
+    m1 = reshape(arange(1, size*size + 1), (size,size))
+    m2 = reshape(arange(1, size*size + 1), (size,size))
+    for i in xrange(iter):
+        mm = matrixmultiply(m1, m2)
+    print mm[0][0], mm[2][3], mm[3][2], mm[4][4]
+
+main()

data/sources/python/message.python

@@ -0,0 +1,24 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+# contributed by Tobias Polzin, translated from Mike Pall's Lua program
+# modified by Brian Atkinson
+
+import sys
+
+def create_coroutine(n):
+	if n > 1:
+		coroutine = create_coroutine(n-1)
+		while 1:
+			yield coroutine.next()+1
+	else:
+		while 1:
+			yield 1
+
+def main():
+	coroutine = create_coroutine( 500 )
+	count = 0
+	for i in xrange( int( sys.argv[1] ) ):
+		count += coroutine.next()
+	print count
+
+main()