chrislo-sourceclassifier 0.2.0

data/sources/python/moments.python

@@ -0,0 +1,65 @@
+#!/usr/bin/python
+# $Id: moments.python,v 1.2 2004-11-30 07:10:04 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+#
+# Updated by Antoine Pitrou
+# 1.  Simple loops are often faster than 'reduce'.
+# 2.  'abs' function is referenced by a local variable.  (Local variables
+#     are optimized by the Python interpreter.
+# 3.  Some loop invariants are lifted to tighten up the code.
+
+import sys, string, math, operator
+
+def main():
+	sum = 0
+	nums = []
+	_abs = abs
+	
+	nums = [float(s) for s in sys.stdin.xreadlines()]
+	for num in nums:
+		sum += num
+#	sum = reduce(operator.add, nums)
+	
+	n = len(nums)
+	mean = sum/n
+	average_deviation = 0
+	standard_deviation = 0
+	variance = 0
+	skew = 0
+	kurtosis = 0
+	
+	for num in nums:
+		deviation = num - mean
+		d2 = deviation**2
+		average_deviation += _abs(deviation)
+		variance += d2
+		skew += deviation*d2
+		kurtosis += d2**2
+	
+	average_deviation /= n
+	variance /= (n - 1)
+	standard_deviation = math.sqrt(variance)
+	
+	if variance > 0.0:
+		skew /= (n * variance * standard_deviation)
+		kurtosis = kurtosis/(n * variance * variance) - 3.0
+	
+	nums.sort()
+	mid = n / 2
+	
+	if (n % 2) == 0:
+		median = (nums[mid] + nums[mid-1])/2
+	else:
+		median = nums[mid]
+	
+	print "n:                  %d" % n
+	print "median:             %f" % median
+	print "mean:               %f" % mean
+	print "average_deviation:  %f" % average_deviation
+	print "standard_deviation: %f" % standard_deviation
+	print "variance:           %f" % variance
+	print "skew:               %f" % skew
+	print "kurtosis:           %f" % kurtosis
+
+main()
+

data/sources/python/nbody.python

@@ -0,0 +1,123 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Kevin Carson
+# modified by Tupteq
+# modified by Fredrik Johansson
+
+import sys
+
+pi = 3.14159265358979323
+solar_mass = 4 * pi * pi
+days_per_year = 365.24
+
+
+def advance(bodies, dt):
+    bodies2 = bodies[1:]
+    for b in bodies:
+        for b2 in bodies2:
+            dx = b[0] - b2[0]
+            dy = b[1] - b2[1]
+            dz = b[2] - b2[2]
+            mag = dt * (dx*dx + dy*dy + dz*dz)**-1.5
+            b_mass_x_mag = b[6] * mag
+            b2_mass_x_mag = b2[6] * mag
+
+            b[3] -= dx * b2_mass_x_mag
+            b[4] -= dy * b2_mass_x_mag
+            b[5] -= dz * b2_mass_x_mag
+            b2[3] += dx * b_mass_x_mag
+            b2[4] += dy * b_mass_x_mag
+            b2[5] += dz * b_mass_x_mag
+        del bodies2[:1]
+
+    for b in bodies:
+        b[0] += dt * b[3]
+        b[1] += dt * b[4]
+        b[2] += dt * b[5]
+
+def energy(bodies):
+    e = 0.0
+    bodies2 = bodies[1:]
+    for b in bodies:
+        e += 0.5 * b[6] * (b[3]*b[3] + b[4]*b[4] + b[5]*b[5])
+        for b2 in bodies2:
+            dx = b[0] - b2[0]
+            dy = b[1] - b2[1]
+            dz = b[2] - b2[2]
+            distance = (dx*dx + dy*dy + dz*dz)**0.5
+            e -= (b[6] * b2[6]) / distance
+        del bodies2[:1]
+
+    return e
+
+def offset_momentum(bodies):
+    global sun
+    px = py = pz = 0.0
+
+    for b in bodies:
+        px += b[3] * b[6]
+        py += b[4] * b[6]
+        pz += b[5] * b[6]
+
+    sun[3] = - px / solar_mass
+    sun[4] = - py / solar_mass
+    sun[5] = - pz / solar_mass
+
+sun = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, solar_mass]
+jupiter = [
+    4.84143144246472090e+00,
+    -1.16032004402742839e+00,
+    -1.03622044471123109e-01,
+    1.66007664274403694e-03 * days_per_year,
+    7.69901118419740425e-03 * days_per_year,
+    -6.90460016972063023e-05 * days_per_year,
+    9.54791938424326609e-04 * solar_mass]
+
+saturn = [
+    8.34336671824457987e+00,
+    4.12479856412430479e+00,
+    -4.03523417114321381e-01,
+    -2.76742510726862411e-03 * days_per_year,
+    4.99852801234917238e-03 * days_per_year,
+    2.30417297573763929e-05 * days_per_year,
+    2.85885980666130812e-04 * solar_mass]
+
+uranus = [
+    1.28943695621391310e+01,
+    -1.51111514016986312e+01,
+    -2.23307578892655734e-01,
+    2.96460137564761618e-03 * days_per_year,
+    2.37847173959480950e-03 * days_per_year,
+    -2.96589568540237556e-05 * days_per_year,
+    4.36624404335156298e-05 * solar_mass]
+
+neptune = [
+    1.53796971148509165e+01,
+    -2.59193146099879641e+01,
+    1.79258772950371181e-01,
+    2.68067772490389322e-03 * days_per_year,
+    1.62824170038242295e-03 * days_per_year,
+    -9.51592254519715870e-05 * days_per_year,
+    5.15138902046611451e-05 * solar_mass]
+
+
+def main():
+    try:
+        n = int(sys.argv[1])
+    except:
+        print "Usage: %s <N>" % sys.argv[0]
+        sys.exit(2)
+
+    bodies = [sun, jupiter, saturn, uranus, neptune]
+    offset_momentum(bodies)
+
+    print "%.9f" % energy(bodies)
+
+    for i in xrange(n):
+        advance(bodies, 0.01)
+
+    print "%.9f" % energy(bodies)
+
+if __name__ == '__main__':
+    main()

data/sources/python/nbody.python-2.python

@@ -0,0 +1,120 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Kevin Carson
+# modified by Tupteq
+# modified by Fredrik Johansson
+# modified by Tupteq (again)
+
+import sys
+
+pi = 3.14159265358979323
+solar_mass = 4 * pi * pi
+days_per_year = 365.24
+
+
+def advance(bodies, dt, n):
+    # Create all possible pairs first
+    pairs = [(b, b2) for i, b in enumerate(bodies) for b2 in bodies[i+1:]]
+    for i in xrange(n):
+        for b, b2 in pairs:
+            dx = b[0] - b2[0]
+            dy = b[1] - b2[1]
+            dz = b[2] - b2[2]
+
+            mag = dt * (dx*dx + dy*dy + dz*dz)**-1.5
+            b_mm = b[6] * mag
+            b2_mm = b2[6] * mag
+
+            b[3] -= dx * b2_mm
+            b[4] -= dy * b2_mm
+            b[5] -= dz * b2_mm
+            b2[3] += dx * b_mm
+            b2[4] += dy * b_mm
+            b2[5] += dz * b_mm
+
+        for b in bodies:
+            b[0] += dt * b[3]
+            b[1] += dt * b[4]
+            b[2] += dt * b[5]
+
+
+def energy(bodies):
+    e = 0.0
+    bodies2 = bodies[1:]
+    for b in bodies:
+        e += 0.5 * b[6] * (b[3]*b[3] + b[4]*b[4] + b[5]*b[5])
+        for b2 in bodies2:
+            dx = b[0] - b2[0]
+            dy = b[1] - b2[1]
+            dz = b[2] - b2[2]
+            distance = (dx*dx + dy*dy + dz*dz)**0.5
+            e -= (b[6] * b2[6]) / distance
+        del bodies2[:1]
+
+    return e
+
+
+def offset_momentum(bodies):
+    global sun
+    px = py = pz = 0.0
+
+    for b in bodies:
+        px -= b[3] * b[6]
+        py -= b[4] * b[6]
+        pz -= b[5] * b[6]
+
+    sun[3] = px / solar_mass
+    sun[4] = py / solar_mass
+    sun[5] = pz / solar_mass
+
+
+sun = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, solar_mass]
+
+jupiter = [
+    4.84143144246472090e+00,
+    -1.16032004402742839e+00,
+    -1.03622044471123109e-01,
+    1.66007664274403694e-03 * days_per_year,
+    7.69901118419740425e-03 * days_per_year,
+    -6.90460016972063023e-05 * days_per_year,
+    9.54791938424326609e-04 * solar_mass]
+
+saturn = [
+    8.34336671824457987e+00,
+    4.12479856412430479e+00,
+    -4.03523417114321381e-01,
+    -2.76742510726862411e-03 * days_per_year,
+    4.99852801234917238e-03 * days_per_year,
+    2.30417297573763929e-05 * days_per_year,
+    2.85885980666130812e-04 * solar_mass]
+
+uranus = [
+    1.28943695621391310e+01,
+    -1.51111514016986312e+01,
+    -2.23307578892655734e-01,
+    2.96460137564761618e-03 * days_per_year,
+    2.37847173959480950e-03 * days_per_year,
+    -2.96589568540237556e-05 * days_per_year,
+    4.36624404335156298e-05 * solar_mass]
+
+neptune = [
+    1.53796971148509165e+01,
+    -2.59193146099879641e+01,
+    1.79258772950371181e-01,
+    2.68067772490389322e-03 * days_per_year,
+    1.62824170038242295e-03 * days_per_year,
+    -9.51592254519715870e-05 * days_per_year,
+    5.15138902046611451e-05 * solar_mass]
+
+
+def main():
+    n = int(sys.argv[1])
+    bodies = [sun, jupiter, saturn, uranus, neptune]
+    offset_momentum(bodies)
+    print "%.9f" % energy(bodies)
+    advance(bodies, 0.01, n)
+    print "%.9f" % energy(bodies)
+
+
+main()

data/sources/python/nestedloop.python

@@ -0,0 +1,24 @@
+#!/usr/bin/python
+# $Id: nestedloop.python,v 1.1.1.1 2004-05-19 18:10:57 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from Mark Baker
+
+import sys
+
+def main():
+    x = 0
+    iter = int(sys.argv[1])
+    if iter < 1:
+        iter = 1
+    
+    i_r = range(iter)
+    for a in i_r:
+        for b in i_r:
+            for c in i_r:
+                for d in i_r:
+                    for e in i_r:
+                        for f in i_r:
+                            x += 1
+    print x
+
+main()

data/sources/python/nsieve.python

@@ -0,0 +1,27 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# Written by Nate Atkinson, 2008-4-4
+# Based on code by Dima Dorfman, Heinrich Acker, Dani Nanz
+
+import sys
+
+N = int(sys.argv[1])
+M = ((2 ** N) * 10000)
+MP = M // 2
+BL = [False, False] + ([True] * (M - 1))
+for I, IP in enumerate(BL):
+    if IP and (I <= MP):
+        BL[I + I::I] = [False] * ((M - I) // I)
+
+OL = []
+a = 0
+c = 0
+for x in range(N - 2, N + 1):
+    b = (1<< x) * 10000
+    c += sum(BL[a:b])
+    OL.append((b, c))
+    a = b
+
+OL.reverse()
+for x, y in OL:
+    print "Primes up to %8d %8d" %(x, y)

data/sources/python/nsieve.python-2.python

@@ -0,0 +1,23 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# Written by Nate Atkinson, 2007-12-19
+# Based on code by Dima Dorfman, Heinrich Acker, Dani Nanz
+
+def sieve(M):
+    PC = 0
+    MP = M // 2
+    BL = [False, False] + ([True] * (M - 1))
+    for I, IP in enumerate(BL):
+        if IP:
+            PC += 1
+            if(I <= MP):
+                BL[I + I::I] = [False] * ((M - I) // I)
+    print "Primes up to %8d %8d" %(M, PC)
+
+
+
+import sys
+
+N = int(sys.argv[1])
+ML = [((2 ** N) * 10000), ((2 ** (N - 1)) * 10000), ((2 ** (N - 2)) * 10000)]
+map(sieve, ML)

data/sources/python/nsieve.python-4.python

@@ -0,0 +1,25 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# Written by Dima Dorfman, 2004
+
+# modified by Heinrich Acker
+# modified by Dani Nanz 2007-10-03
+
+import sys
+from itertools import count, islice, izip
+
+
+def nsieve(m, c=0):
+
+    a = [True] * (m + 1)
+    iu = m // 2    # faster but not compliant: iu = int(m ** 0.5)
+    for i, x in izip(count(2), islice(a, 2, None)):
+        if x:
+            c += 1
+            if i <= iu:
+                a[i + i :: i] = (False, ) * ((m - i) // i)
+    print 'Primes up to %8d %8d' % (m, c)
+
+
+for k in 0, 1, 2:
+    nsieve((1 << (int(sys.argv[1]) - k)) * 10000)

data/sources/python/nsievebits.python

@@ -0,0 +1,27 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Kevin Carson
+# optimized by Giovanni Bajo
+# modified by Heinrich Acker
+
+import sys, itertools
+
+def primes_in_range(M):
+    bits = [0xFF]*((M + 7) // 8)
+    set_bits = [1 << (j+2 & 7) for j in range(8)]
+    unset_bits = [~(1 << j) for j in range(8)]
+
+    count = 0
+    for i, sb in itertools.izip(xrange(2, M), itertools.cycle(set_bits)):
+        if bits[i>>3] & sb:
+            for j in xrange(i+i, M, i):
+                bits[j>>3] &= unset_bits[j&7]
+            count += 1
+
+    print "Primes up to %8u %8u" % (M, count)
+
+N = int(sys.argv[1])
+for j in range(3):
+    M = (1 << N-j) * 10000
+    primes_in_range(M)

data/sources/python/nsievebits.python-2.python

@@ -0,0 +1,43 @@
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org/
+#
+# contributed by Kevin Carson (Python 2.4 or greater required)
+# optimized by Giovanni Bajo
+
+import sys
+
+def primes_in_range(M) :
+    bits = [0xFF]*((M + 7) // 8)
+    set_bits = [1 << i for i in range(8)]
+    unset_bits = [~(1 << i) for i in range(8)]
+
+    count = 0
+    for i in xrange(2, M) :
+        if bits[i>>3] & set_bits[i&7]:
+            for j in xrange(i*2, M, i):
+                bits[j>>3] &= unset_bits[j&7]
+            count += 1
+
+    return count
+
+def Usage() :
+    print "Usage: %s <N >= 2>" % sys.argv[0]
+
+
+def main() :
+    if len(sys.argv) == 2 :
+        N = int(sys.argv[1])
+        if N < 2 :
+            Usage()
+            return
+    else :
+        Usage()
+        return
+
+    for i in xrange(0,3) :
+        M = (1 << (N - i)) * 10000
+        count = primes_in_range(M)
+        print "Primes up to %8u %8u" % (M, count)
+
+main()
+