chrislo-sourceclassifier 0.2.0

data/sources/python/threadring.python-2.python

@@ -0,0 +1,40 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# Contributed by Antti Kervinen
+# Modified by Tupteq
+
+import sys
+import thread
+
+# Set minimum stack size for threads, otherwise the program may fail
+# to create such a many threads
+thread.stack_size(32*1024)
+
+def threadfun(number, lock_acquire, next_release):
+    global n
+    while 1:
+        lock_acquire()
+        if n > 0:
+            n -= 1
+            next_release()
+        else:
+            print number
+            main_lock.release()
+
+# main
+n = int(sys.argv[1])
+main_lock = thread.allocate_lock()
+main_lock.acquire()
+
+first_lock = thread.allocate_lock()
+next_lock = first_lock
+
+for number in xrange(503):
+    lock = next_lock
+    lock.acquire()
+    next_lock = thread.allocate_lock() if number < 502 else first_lock
+    thread.start_new_thread(threadfun,
+        (number+1, lock.acquire, next_lock.release))
+
+first_lock.release()
+main_lock.acquire()

data/sources/python/threadring.python-3.python

@@ -0,0 +1,34 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Daniel Nanz 2008-03-11
+# --------------------------------------------
+# Coroutines via enhanced generators
+# (http://www.python.org/dev/peps/pep-0342/)
+
+import sys
+import itertools
+      
+def main(n = int(sys.argv[1]), n_threads=503, cycle=itertools.cycle):
+
+    def worker(worker_id):
+        
+        n = 1
+        while True:
+            if n > 0:
+                n = (yield (n - 1))
+            else:
+                print worker_id
+                raise StopIteration
+
+
+    threadRing = [worker(w) for w in xrange(1, n_threads + 1)]
+    for t in threadRing: foo = t.next()           # start exec. gen. funcs
+    sendFuncRing = [t.send for t in threadRing]   # speed...
+    for send in cycle(sendFuncRing):
+        try:
+            n = send(n)
+        except StopIteration:
+            break
+
+main()

data/sources/python/wc.python-2.python

@@ -0,0 +1,19 @@
+#!/usr/bin/python
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# contributed by kosh
+
+import sys
+
+def main():
+    nl = nw = nc = 0
+
+    for line in sys.stdin:
+        nl += 1
+        nc += len(line)
+        nw += len(line.split())
+
+    print "%d %d %d" % (nl, nw, nc)
+
+main()

data/sources/python/wordfreq.python

@@ -0,0 +1,43 @@
+#!/usr/bin/python
+# $Id: wordfreq.python,v 1.2 2004-07-03 05:36:11 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+#
+# adapted from Bill Lear's original python word frequency counter
+#
+# Joel Rosdahl suggested using translate table to speed up
+# word splitting.  That change alone sped this program up by
+# at least a factor of 3.
+#
+# with further speedups from Mark Baker
+
+import sys
+
+def main():
+    count = {}
+    i_r = map(chr, range(256))
+
+    trans = [' '] * 256
+    o_a, o_z = ord('a'), (ord('z')+1)
+    trans[ord('A'):(ord('Z')+1)] = i_r[o_a:o_z]
+    trans[o_a:o_z] = i_r[o_a:o_z]
+    trans = ''.join(trans)
+
+    rl = sys.stdin.readlines
+
+    lines = rl(4095)
+    while lines:
+        for line in lines:
+            for word in line.translate(trans).split():
+                try:
+                    count[word] += 1
+                except KeyError:
+                    count[word] = 1
+        lines = rl(4095)
+
+    l = zip(count.values(), count.keys())
+    l.sort()
+    l.reverse()
+
+    print '\n'.join(["%7s %s" % (count, word) for (count, word) in l])
+
+main()

data/sources/python/wordfreq.python-3.python

@@ -0,0 +1,28 @@
+import sys, re, string
+
+def main():
+    count = {}
+    p = re.compile(r'[^a-z]')
+    for word in p.split(string.lower(sys.stdin.read())):
+        if not word: continue
+        count[word] = count.get(word, 0) + 1
+
+    bucket = {}
+    for key, val in count.items():
+        if not bucket.has_key(val):
+            bucket[val] = []
+        bucket[val].append(key)
+
+    freqs = bucket.keys()
+    freqs.sort()
+    freqs.reverse()
+
+    for freq in freqs:
+        words = bucket[freq]
+        words.sort()
+        words.reverse()
+        for word in words:
+            print "%7d\t%s" % (freq, word)
+
+main()
+sys.stdout.flush()

data/sources/python/wordfreq.python-4.python

@@ -0,0 +1,38 @@
+import sys, re, string
+
+def main():
+    # count is a dictionary of word counts
+    count = {}
+    # speed up function call by making a local alias
+    lower = string.lower
+    nextline = sys.stdin.readline
+    p = re.compile(r'[^a-z]')
+    while 1:
+        line = nextline()
+        if not line: break
+        for word in p.split(lower(line)):
+            if not count.has_key(word):
+                count[word] = 1
+            else:
+                count[word] = count[word] + 1
+
+    bucket = {}
+    for key, val in count.items():
+        if not bucket.has_key(val):
+            bucket[val] = []
+        bucket[val].append(key)
+
+    freqs = bucket.keys()
+    freqs.sort()
+    freqs.reverse()
+
+    for freq in freqs:
+        words = bucket[freq]
+        words.sort()
+        words.reverse()
+        for word in words:
+            if len(word) > 0:
+                print "%7d\t%s" % (freq, word)
+
+main()
+sys.stdout.flush()

data/sources/python/wordfreq.python-5.python

@@ -0,0 +1,39 @@
+import sys, re, string, fileinput
+
+def main():
+    # count is a dictionary of word counts
+    count = {}
+    # speed up function call by making a local alias
+    lower = string.lower
+    #nextline = sys.stdin.readline
+    p = re.compile(r'[^a-z]')
+    #while 1:
+    #    line = nextline()
+    #    if not line: break
+    for line in fileinput.input('-'):
+        for word in p.split(lower(line)):
+            if not count.has_key(word):
+                count[word] = 1
+            else:
+                count[word] = count[word] + 1
+
+    bucket = {}
+    for key, val in count.items():
+        if not bucket.has_key(val):
+            bucket[val] = []
+        bucket[val].append(key)
+
+    freqs = bucket.keys()
+    freqs.sort()
+    freqs.reverse()
+
+    for freq in freqs:
+        words = bucket[freq]
+        words.sort()
+        words.reverse()
+        for word in words:
+            if len(word) > 0:
+                print "%7d\t%s" % (freq, word)
+
+main()
+sys.stdout.flush()

data/sources/ruby/ackermann.ruby

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: ackermann.ruby,v 1.2 2005-06-10 00:57:22 igouy-guest Exp $
+# http://www.bagley.org/~doug/shootout/ 
+
+def ack(m, n)
+    if m == 0 then
+	n + 1
+    elsif n == 0 then
+	ack(m - 1, 1)
+    else
+	ack(m - 1, ack(m, n - 1))
+    end
+end
+
+NUM = Integer(ARGV.shift || 1)
+print "Ack(3,", NUM, "): ", ack(3, NUM), "\n"

data/sources/ruby/ackermann.ruby-5.ruby

@@ -0,0 +1,153 @@
+#!/usr/bin/ruby
+# The Computer Language Benchmark Shootout
+# http://shootout.alioth.debian.org
+#
+# original code by Martin DeMello
+# modified by Jabari Zakiya 3/20/05
+# modified by Glenn Parker 3/28/05 (format results)
+
+include Math
+
+SOLAR_MASS = 4*PI*PI
+DAYS_PER_YEAR = 365.24
+
+Vector3D = Struct.new("Vector3D", :x, :y, :z)
+
+class Vector3D
+
+  def *(val)
+    Vector3D.new(*self.map {|i| i * val})
+  end
+
+  def /(val)
+    Vector3D.new(*self.map {|i| i / val})
+  end
+
+  #in-place add with scale
+  # a.adds(b, s) -> a += b*s
+
+  def adds(other, scale)
+    self[0] += other[0]*scale; self[1] += other[1]*scale
+    self[2] += other[2]*scale
+  end
+
+  def subs(other, scale)
+    self[0] -= other[0]*scale; self[1] -= other[1]*scale
+    self[2] -= other[2]*scale
+  end
+
+  def magnitude
+    x=self[0]; y=self[1]; z=self[2]
+    sqrt(x*x + y*y + z*z)
+  end
+
+  # |self - other|
+  def dmag(other)
+    x=self[0]-other[0]; y=self[1]-other[1]; z=self[2]-other[2]
+    sqrt(x*x + y*y + z*z)
+  end
+end
+
+class Planet
+  attr_accessor :pos, :v, :mass
+
+  def initialize(x, y, z, vx, vy, vz, mass)
+    @pos = Vector3D.new(x, y, z)
+    @v = Vector3D.new(vx, vy, vz) * DAYS_PER_YEAR
+    @mass = mass * SOLAR_MASS
+  end
+
+  def distance(other)
+    self.pos.dmag(other.pos)
+  end
+end
+
+jupiter = Planet.new(
+   4.84143144246472090e+00,
+   -1.16032004402742839e+00,
+   -1.03622044471123109e-01,
+   1.66007664274403694e-03,
+   7.69901118419740425e-03,
+   -6.90460016972063023e-05,
+   9.54791938424326609e-04)
+
+saturn = Planet.new(
+   8.34336671824457987e+00,
+   4.12479856412430479e+00,
+   -4.03523417114321381e-01,
+   -2.76742510726862411e-03,
+   4.99852801234917238e-03,
+   2.30417297573763929e-05,
+   2.85885980666130812e-04)
+
+uranus = Planet.new(
+   1.28943695621391310e+01,
+   -1.51111514016986312e+01,
+   -2.23307578892655734e-01,
+   2.96460137564761618e-03,
+   2.37847173959480950e-03,
+   -2.96589568540237556e-05,
+   4.36624404335156298e-05)
+
+neptune = Planet.new(
+   1.53796971148509165e+01,
+   -2.59193146099879641e+01,
+   1.79258772950371181e-01,
+   2.68067772490389322e-03,
+   1.62824170038242295e-03,
+   -9.51592254519715870e-05,
+   5.15138902046611451e-05)
+
+sun = Planet.new(0, 0, 0, 0, 0, 0, 1)
+
+class Array
+  def each_pair
+    a = []
+    each_index {|i|
+      ((i+1)...length).each {|j|
+        yield at(i), at(j)
+      }
+    }
+  end
+end
+
+bodies = [sun, jupiter, saturn, uranus, neptune]
+
+class << bodies
+  def advance(dt)
+    mag = m1 = m2 = nil
+    each_pair {|b1, b2|
+      d = b1.distance(b2)
+      mag = dt/(d*d*d)
+
+      m1 = b1.mass * mag
+      m2 = b2.mass * mag
+
+      b1.v.adds(b2.pos, m2)
+      b1.v.subs(b1.pos, m2)
+      b2.v.adds(b1.pos, m1)
+      b2.v.subs(b2.pos, m1)
+    }
+
+    each {|b| b.pos.adds(b.v, dt)}
+  end
+
+  def energy
+    e = 0
+    each {|b| e += 0.5 * b.mass * (b.v.magnitude ** 2) }
+    each_pair {|b1, b2| e -= (b1.mass * b2.mass) / b1.distance(b2) }
+    e
+  end
+
+  def offset_momentum
+    p = Vector3D.new(0,0,0)
+    sun = self[0]
+    each {|b| p.adds(b.v, b.mass) }
+    sun.v.subs(p, 1.0/sun.mass)
+  end
+end
+
+bodies.offset_momentum
+puts "%.9f" % bodies.energy
+Integer(ARGV[0]).times { bodies.advance(0.01) }
+puts "%.9f" % bodies.energy

data/sources/ruby/ary.ruby

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: ary.ruby,v 1.3 2004-06-20 08:39:45 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from Paul Brannan and Mark Hubbart
+
+n = Integer(ARGV.shift || 1)
+
+x = Array.new(n)
+y = Array.new(n, 0)
+
+for i in 0 ... n
+  x[i] = i + 1
+end
+
+(0 .. 999).each do
+  (n-1).step(0,-1) do |i|
+    y[i] += x.at(i)
+  end
+end
+
+puts "#{y.first} #{y.last}"