chrislo-sourceclassifier 0.2.0

data/sources/python/except.python

@@ -0,0 +1,62 @@
+#!/usr/bin/python
+# http://www.bagley.org/~doug/shootout/ 
+
+import sys
+
+HI = 0
+LO = 0
+
+
+class Hi_exception:
+    def __init__(self, value):
+        self.value = value
+    def __str__(self):
+        return `self.value`
+
+
+class Lo_exception:
+    def __init__(self, value):
+        self.value = value
+    def __str__(self):
+        return `self.value`
+
+
+def some_function(num):
+    try:
+        hi_function(num)
+    except:
+        raise "We shouldn't get here (%s)" % sys.exc_info()[0]
+
+
+def hi_function(num):
+    global HI
+    try:
+        lo_function(num)
+    except Hi_exception, ex:
+        HI += 1
+        #print 'Hi_exception occurred, value:', ex.value
+
+
+def lo_function(num):
+    global LO
+    try:
+        blowup(num)
+    except Lo_exception, ex:
+        LO += 1
+        #print 'Lo_exception occurred, value:', ex.value
+
+
+def blowup(num): 
+    raise (((num & 1) and Lo_exception) or Hi_exception)(num)
+
+def main():
+    global LO, HI
+    NUM = int(sys.argv[1])
+    if NUM < 1:
+        NUM = 1
+    for i in xrange(NUM-1,-1,-1):
+        some_function(i)
+    print "Exceptions: HI=%d / LO=%d" % (HI, LO)
+
+
+main()

data/sources/python/fannkuch.python

@@ -0,0 +1,50 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# Contributed by Sokolov Yura
+
+from sys import argv
+def fannkuch(n):
+   count = range(1,n+1)
+   maxFlipsCount, m, r, check = 0, n-1, n, 0
+
+   perm1 = range(n)
+   perm  = range(n)
+   perm1_ins = perm1.insert
+   perm1_pop = perm1.pop
+   while True:
+      if check < 30:
+         print "".join(`i+1` for i in perm1)
+         check += 1;
+
+      while r != 1:
+         count[r-1] = r
+         r -= 1
+
+      if perm1[0] != 0 and perm1[m] != m:
+         perm[:]=perm1
+         flipsCount = 0
+         k = perm[0]
+         while k:
+            perm[:k+1] = perm[k::-1]
+            flipsCount += 1
+            k = perm[0]
+
+         if flipsCount > maxFlipsCount:
+            maxFlipsCount = flipsCount
+            maxPerm = list(perm1)
+
+      while True:
+         if r == n: return maxFlipsCount
+         perm1_ins(r,perm1_pop(0))
+         count[r] -= 1
+         if count[r] > 0: break
+         r += 1
+
+def main():
+    n = int(argv and argv[1] or 1)
+    print "Pfannkuchen(%d) = %d\n"%(n,fannkuch(n)),
+
+if __name__=="__main__":
+    main()
+

data/sources/python/fannkuch.python-2.python

@@ -0,0 +1,54 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Sokolov Yura
+# modified by Tupteq
+
+def fannkuch(n):
+    count = range(1, n+1)
+    max_flips = 0
+    m = n-1
+    r = n
+    check = 0
+    perm1 = range(n)
+    perm = range(n)
+    perm1_ins = perm1.insert
+    perm1_pop = perm1.pop
+
+    while 1:
+        if check < 30:
+            print "".join(str(i+1) for i in perm1)
+            check += 1
+
+        while r != 1:
+            count[r-1] = r
+            r -= 1
+
+        if perm1[0] != 0 and perm1[m] != m:
+            perm = perm1[:]
+            flips_count = 0
+            k = perm[0]
+            while k:
+                perm[:k+1] = perm[k::-1]
+                flips_count += 1
+                k = perm[0]
+
+            if flips_count > max_flips:
+                max_flips = flips_count
+
+        while r != n:
+            perm1_ins(r, perm1_pop(0))
+            count[r] -= 1
+            if count[r] > 0:
+                break
+            r += 1
+        else:
+            return max_flips
+
+def main():
+    from sys import argv
+    n = int(argv and argv[1] or 1)
+    print "Pfannkuchen(%d) = %d\n" % (n, fannkuch(n)),
+
+if __name__=="__main__":
+    main()

data/sources/python/fasta.python-2.python

@@ -0,0 +1,79 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# modified by Ian Osgood
+# modified again by Heinrich Acker
+
+import sys, bisect
+
+alu = (
+   'GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG'
+   'GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA'
+   'CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT'
+   'ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA'
+   'GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG'
+   'AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC'
+   'AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA')
+
+iub = zip('acgtBDHKMNRSVWY', [0.27, 0.12, 0.12, 0.27] + [0.02]*11)
+
+homosapiens = [
+    ('a', 0.3029549426680),
+    ('c', 0.1979883004921),
+    ('g', 0.1975473066391),
+    ('t', 0.3015094502008),
+]
+
+
+def genRandom(lim, ia = 3877, ic = 29573, im = 139968):
+    seed = 42
+    imf = float(im)
+    while 1:
+        seed = (seed * ia + ic) % im
+        yield lim * seed / imf
+
+Random = genRandom(1.)
+
+def makeCumulative(table):
+    P = []
+    C = []
+    prob = 0.
+    for char, p in table:
+        prob += p
+        P += [prob]
+        C += [char]
+    return (P, C)
+
+def repeatFasta(src, n):
+    width = 60
+    r = len(src)
+    s = src + src + src[:n % r]
+    for j in xrange(n // width):
+        i = j*width % r
+        print s[i:i+width]
+    if n % width:
+        print s[-(n % width):]
+
+def randomFasta(table, n):
+    width = 60
+    r = xrange(width)
+    gR = Random.next
+    bb = bisect.bisect
+    jn = ''.join
+    probs, chars = makeCumulative(table)
+    for j in xrange(n // width):
+        print jn([chars[bb(probs, gR())] for i in r])
+    if n % width:
+        print jn([chars[bb(probs, gR())] for i in xrange(n % width)])
+
+
+n = int(sys.argv[1])
+
+print '>ONE Homo sapiens alu'
+repeatFasta(alu, n*2)
+
+print '>TWO IUB ambiguity codes'
+randomFasta(iub, n*3)
+
+print '>THREE Homo sapiens frequency'
+randomFasta(homosapiens, n*5)

data/sources/python/fibo.python

@@ -0,0 +1,17 @@
+#!/usr/bin/python
+# $Id: fibo.python,v 1.3 2005-04-25 19:01:38 igouy-guest Exp $
+# http://www.bagley.org/~doug/shootout/
+
+import sys
+
+def fib(n):
+    if (n < 2):
+        return(1)
+    return( fib(n-2) + fib(n-1) )
+
+def main():
+    N = int(sys.argv[1])
+    #sys.setrecursionlimit(3000)
+    print fib(N)
+
+main()

data/sources/python/harmonic.python-2.python

@@ -0,0 +1,9 @@
+#!/usr/bin/python
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# contributed by Jacob Lee et al.
+
+import sys
+
+print "%.9f" % sum(1.0/i for i in xrange(1, 1+int(sys.argv[1])))

data/sources/python/hash.python

@@ -0,0 +1,21 @@
+#!/usr/bin/python
+# $Id: hash.python,v 1.1.1.1 2004-05-19 18:09:55 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from from Gustavo Niemeyer
+
+import sys
+#sys.setcheckinterval(10000)
+
+def main():
+    n = int(sys.argv[1])
+    X = {}
+    myhex = hex
+    for i in xrange(1,n+1):
+        X[myhex(i)[2:]] = i
+    c = 0
+    has_key = X.has_key
+    for i in xrange(n, 0, -1):
+        c += has_key(`i`)
+    print c
+
+main()

data/sources/python/hash2.python

@@ -0,0 +1,30 @@
+#!/usr/bin/python
+# $Id: hash2.python,v 1.2 2004-11-30 07:10:03 bfulgham Exp $
+# http://shootout.alioth.debian.org
+# Contributed by Antoine Pitrou, based on code by Mark Baker
+#
+# 1.  Put critical code in a function -- otherwise the local variable
+#     optimizations by the interpreter don't work.
+# 2.  Iterator versions of common functions are often a bit faster than
+#     other methods (e.g., iterkeys() instead of keys() ).
+
+import sys
+
+def main():
+  n = int(sys.argv[1])
+  hash1 = {}
+  for i in xrange(10000):
+    hash1['foo_' + `i`] = i
+
+  hash2 = {}
+  for i in xrange(n):
+    for k in hash1.iterkeys():
+      try:
+        hash2[k] += hash1[k]
+      except KeyError:
+        hash2[k] = hash1[k]
+
+  print hash1['foo_1'], hash1['foo_9999'], hash2['foo_1'], hash2['foo_9999']
+
+
+main()

data/sources/python/heapsort.python-3.python

@@ -0,0 +1,66 @@
+#!/usr/bin/python -O
+# $Id: heapsort.python-3.python,v 1.1 2005-03-27 19:43:21 igouy-guest Exp $
+#
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# Updated by Valentino Volonghi for Python 2.4
+# Reworked by Kevin Carson to produce correct results and same intent
+
+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 heapsort(n, ra) :
+    ir = n
+    l = (n >> 1) + 1
+
+    while True :
+        if l > 1 :
+            l -= 1
+            rra = ra[l]
+        else :
+            rra = ra[ir]
+            ra[ir] = ra[1]
+            ir -= 1
+            if ir == 1 :
+                ra[1] = rra
+                return
+
+        i = l
+        j = l << 1
+        while j <= ir :
+            if (j < ir) and (ra[j] < ra[j + 1]) :
+                j += 1
+
+            if rra < ra[j] :
+                ra[i] = ra[j]
+                i = j
+                j += j
+            else :
+                j = ir + 1;
+        ra[i] = rra;
+
+def main() :
+    if len(sys.argv) == 2 :
+        N = int(sys.argv[1])
+    else :
+        N = 1
+
+    ary = [None]*(N + 1)
+    for i in xrange(1, N + 1) :
+        ary[i] = gen_random(1.0)
+
+    heapsort(N, ary)
+
+    print "%.10f" % ary[N]
+
+main()

data/sources/python/hello.python

@@ -0,0 +1,5 @@
+#!/usr/bin/python
+# $Id: hello.python,v 1.1.1.1 2004-05-19 18:10:16 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+print "hello world"

data/sources/python/implicitode.python

@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+#
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/ 
+#
+# Contributed by Sebastien Loisel
+#
+# OVERVIEW: In this test, we solve an ordinary differential equation
+#    u'=f(t,u)
+# using the Trapezoid numerical method, which can be written as
+#    (u[k+1]-u[k])=(f(t[k],u[k])+f(t[k]+dt,u[k+1]))*dt/2,
+# where t[k], u[k], dt and the function f are known and u[k+1] is the
+# unknown.
+#
+# Since u[k+1] appears on both sides of the equation, we use an iterative
+# solver called the newton iteration to compute u[k+1]. The newton iteration
+# computes the solution to
+#    h(x)=0
+# where h is a known function and x is the unknown 0 of h, using the method
+#    x[k+1]=x[k]-f(x[k])/f'(x[k]).
+# Here, f' denotes the derivative of f.
+#
+# To compute f' from the definition of f alone, we use a technique called
+# automatic differentiation. This works by replacing all floating point
+# variables by a special type we call ad (for automatic differentiation.)
+# If the python program for f is called with parameter x of type ad,
+# it will do the same work as if it were called with the equivalent parameter
+# of type floating point, but will also return f'. That's why it's called
+# "automatic."
+#
+# To shake things up, we also have another type, fl (for "float") which
+# works exactly like a double precision floating point, but with much
+# less precision.
+#
+# Summary of classes:
+#
+# ad -- automatic differentiation type
+# fl -- low precision floating point type
+# mycomplex -- complex numbers whose real and imaginary parts can be fl
+# trapezoid_method_rooter -- implements the function that the trapezoid method
+#                            must solve
+
+import sys
+from math import log,exp,floor,fabs
+
+def sqr(x):
+    """sqr(x): a helper function that computes the square of any "number" x."""
+    return x*x
+
+def pwr(x,k):
+    """pwr(x,k): a helper function that computes the kth power of any
+    "number" x."""
+    if k<=0:
+        return 1
+    elif (k&1):
+        return x*pwr(x,k-1)
+    return sqr(pwr(x,k/2))
+
+def pr(x):
+    """Print a value depending on its type."""
+    if isinstance(x,float):
+        return "%.12e"%x
+    elif isinstance(x,complex):
+        return "%.12e %.12e"%(x.real,x.imag)
+    else:
+        return x.pr()
+
+class fl:
+    """A low-precision floating point class."""
+    def pr(x):
+        return "%.2e"%x.a
+    def __init__(x,a=0):
+        global count
+        if a==0:
+            x.a=0.0
+        else:
+            k=int(log(fabs(a)))
+            x.a=floor(a*exp(-k+6)+0.5)*exp(k-6)
+    def __add__(x,y):
+        return fl(x.a+y.a)
+    def __radd__(y,x):
+        return x+y
+    def __sub__(x,y):
+        return fl(x.a-y.a)
+    def __mul__(x,y):
+        return fl(x.a*y.a)
+    def __rmul__(y,x):
+        return x*y
+    def __div__(x,y):
+        return fl(x.a/y.a)
+    def __coerce__(x,y):
+        if isinstance(y,fl):
+            return (x,y)
+        return (x,fl(y))
+
+class mycomplex:
+    """A complex type so that the type of the real or imaginary part can be
+    any kind of number."""
+    def __init__(x,a=0,b=0):
+        x.real,x.imag=a,b
+    def __add__(a,b):
+        return mycomplex(a.real+b.real,a.imag+b.imag)
+    def __radd__(b,a):
+        return a+b
+    def __sub__(a,b):
+        return mycomplex(a.real-b.real,a.imag-b.imag)
+    def __mul__(a,b):
+        return mycomplex(a.real*b.real-a.imag*b.imag,
+                         a.real*b.imag+a.imag*b.real)
+    def __rmul__(b,a):
+        return a*b
+    def __div__(a,b):
+        mag=b.real*b.real+b.imag*b.imag
+        return mycomplex((a.real*b.real+a.imag*b.imag)/mag,
+                         (a.imag*b.real-a.real*b.imag)/mag)
+    def __coerce__(a,b):
+        if isinstance(b,mycomplex):
+            return (a,b)
+        return (a,mycomplex(b))
+    def pr(a):
+        return pr(a.real)+' '+pr(a.imag)
+
+def one(x):
+    if isinstance(x,float):
+        return 1.0
+    if isinstance(x,complex):
+        return 1.0+0.0j
+    if isinstance(x,fl):
+        return fl(1.0)
+    if isinstance(x,mycomplex):
+        return mycomplex(one(x.real),0.0)
+
+class ad:
+    """Automatic differentiation type. An ad has two attributes, x and dx."""
+    def __init__(self,x=0,dx=0):
+        self.x,self.dx=x,dx
+    def __add__(a,b):
+        """ad's add like vectors."""
+        return ad(a.x+b.x,a.dx+b.dx)
+    def __sub__(a,b):
+        """ad's subtract like vectors."""
+        return ad(a.x-b.x,a.dx-b.dx)
+    def __mul__(a,b):
+        """The product of ad's is given by the "product rule" of differentation:
+        (x,dx)*(y,dy)=(xy,xdy+ydx)."""
+	return ad(a.x*b.x,a.dx*b.x+a.x*b.dx)
+    def __div__(a,b):
+        """The quotient rule of differentiation gives
+        (x,dx)/(y,dy)=(x/y,(ydx-xdy)/(y*y))."""
+        return ad(a.x/b.x,(a.dx*b.x-a.x*b.dx)/(b.x*b.x))
+    def __coerce__(self,other):
+        if isinstance(other,ad):
+            return (self,other)
+        return (self,ad(other))
+    def pr(a):
+        return pr(a.x)+' '+pr(a.dx)
+
+def rat(x):
+    """This is just a quotient of two polynomials p/q, with degree p=11 and
+    degree q=7."""
+    return (x*2+pwr(x,2)*3+pwr(x,6)*7+pwr(x,11)*5+1)/(x*5-pwr(x,3)*6-pwr(x,7)*3+2)
+
+def newton(x0,n,g):
+    """The newton iteration computes the zero of g starting with initial guess
+    x0. This implementation iterates n times and then returns the answer."""
+    for i in range(n):
+        val=g(ad(x0,one(x0)))
+        x0=x0-val.x/val.dx
+    return x0
+
+def mysqrt(x):
+    """This isn't actually a square root. However, newton(1,10,mysqrt) should
+    return the square root of 2 (1.4142...)."""
+    return sqr(x)-ad(2)
+
+class trapezoid_method_rooter:
+    """The trapezoid method (see below) works by computing the solution of some
+    problem of the form h(x)=0. This class implements the function h needed
+    in the trapezoid method."""
+    def __init__(self,g,y0,t0,t1):
+        self.g,self.y0,self.t0,self.t1=g,y0,t0,t1
+        self.g0=g(t0,y0)
+    def __call__(self,y1):
+        """The function is (g(t1,y1)-g(t0,y0))*(t1-t0)/2+y0-y1. The parameters
+        t0,y0,t1,g are set at construction time, so the only parameter left is
+        y1."""
+#        raz=(self.g(ad(self.t1),y1))
+        ret=(self.g(ad(self.t1),y1)+self.g0)*((self.t1-self.t0)/2)+ad(self.y0)-y1
+#        print "t0",pr(self.t0),"t1",pr(self.t1),"y0",pr(self.y0),"g0",pr(self.g0),"y1",pr(y1),"ret",pr(ret),"raz",pr(raz)
+        return ret
+
+def trapezoid_method(t0,dt,y0,g,numsteps):
+    """This function will approximate the solution of y'=g(t,y) at time
+    t0+numsteps*dt with initial value y(t0)=y0 using the trapezoid method
+    of numerical integration."""
+    for i in range(numsteps):
+        foo=trapezoid_method_rooter(g,y0,t0,t0+dt)
+        y0=newton(y0,10,foo)
+        t0=t0+dt
+    return y0
+
+def sqrintegrand(t,y):
+    """This is a version of sqr which has the correct signature so that it can
+    be passed to trapezoid_method. The first parameter, t, is ignored.
+    The second parameter, y, is passed on to sqr."""
+    return sqr(y)
+def ratintegrand(t,y):
+    """This is a version of the rational function rat above that can be passed
+    to trapezoid_method. In this instance, we do use the t parameter."""
+    return rat(y)-t
+
+def integrate_functions(t0,x0,dt,n):
+    """Integrate sqrintegrand and ratintegrand with given initial value.
+    Depending on the type of initial value, this will result in float, complex,
+    iv or complex iv integration."""
+    print ('i1 '+pr(trapezoid_method(t0,dt,x0,sqrintegrand,n)))
+    print ('i2 '+pr(trapezoid_method(t0,dt,x0,ratintegrand,n)))
+
+try:
+    N = int(sys.argv[1])
+except:
+    N = 50
+print ('rational_taylor_series: '+pr(rat(ad(0.25,1))))
+print ('newton-sqrt_2: '+pr(newton(1.0,10,mysqrt)))
+x=newton(-1.0,6,rat)
+print ('newton-rat: '+pr(x))
+integrate_functions(1.0,0.02,1.0/(4*N),4*N)
+integrate_functions(fl(1.0),fl(0.02),fl(1.0)/fl(float(N)),N)
+integrate_functions(1.0+0.0j,0.02+0.02j,1.0/N,N)
+integrate_functions(mycomplex(fl(1.0),fl(0.0)),mycomplex(fl(0.02),fl(0.02)),mycomplex(fl(1.0))/mycomplex(fl(float(N))),N)
+