chrislo-sourceclassifier 0.2.0

data/sources/perl/threadring.perl

@@ -0,0 +1,55 @@
+#  The Computer Language Benchmarks Game
+#  http://shootout.alioth.debian.org/
+
+#  contributed by Richard Cottrill
+
+
+use strict;
+use warnings;
+use threads;
+use threads::shared;
+use Thread::Semaphore;
+
+my $numThreads	:shared;
+my $data	:shared;
+my $result	:shared;
+my @mutex	:shared;
+
+$numThreads = 503;
+
+sub thr_func {
+  my ($nextThread, $thr_name);
+  $thr_name = threads->tid();
+  threads->detach();
+  if ($thr_name == $numThreads) {
+    $nextThread = 1;
+  }
+  else {
+    $nextThread = $thr_name + 1;
+  }
+  while (1) {
+    $mutex[$thr_name]->down();
+    if ($data) {
+      $data = --$data;
+      $mutex[$nextThread]->up();
+    }
+    else {
+      $result = $thr_name;
+      $mutex[0]->up();
+    }
+  } 
+}
+
+$data = $ARGV[0];
+
+$mutex[0] = new Thread::Semaphore(0);
+{
+  for (1 .. $numThreads) {
+    $mutex[$_] = new Thread::Semaphore(0);
+    threads->create(\&thr_func);
+  }
+}
+$mutex[1]->up();
+$mutex[0]->down();
+print "$result\n";
+exit(0);

data/sources/perl/threadring.perl-2.perl

@@ -0,0 +1,43 @@
+#  The Computer Language Benchmarks Game
+#  http://shootout.alioth.debian.org/
+
+# contributed by Marc Lehmann
+
+use strict;
+use Coro;
+use Coro::Semaphore;
+
+my $threads = 503;
+my $result;
+my @data = $ARGV[0];
+my @mutex;
+
+sub thr_func {
+   my ($id, $next) = @_;
+
+   my $next = ($id + 1) % $threads;
+  
+   while () {
+      $mutex[$id]->down;
+
+      if ($data[$id]) {
+        $data[$next] = $data[$id] - 1;
+        $mutex[$next]->up;
+      } else {
+        $result = $next;
+        print "$next\n";
+        exit;
+     }
+   }
+}
+
+
+for (0 .. $threads - 1) {
+   $mutex[$_] = new Coro::Semaphore 0;
+   async \&thr_func, $_;
+}
+
+$mutex[0]->up;
+schedule;
+
+

data/sources/perl/wc.perl

@@ -0,0 +1,20 @@
+#!/usr/bin/perl
+# $Id: wc.perl,v 1.1.1.1 2004-05-19 18:13:51 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+# this program is modified from:
+#   http://cm.bell-labs.com/cm/cs/who/bwk/interps/pap.html
+# Timing Trials, or, the Trials of Timing: Experiments with Scripting
+# and User-Interface Languages</a> by Brian W. Kernighan and
+# Christopher J. Van Wyk.
+
+use strict;
+
+my($nl, $nw, $nc);
+while (read(STDIN, $_, 4095)) {
+    $_ .= <STDIN>;
+    $nl += scalar(split(/\n/));
+    $nc += length;
+    $nw += scalar(split);
+}
+print "$nl $nw $nc\n";

data/sources/perl/wc.perl-2.perl

@@ -0,0 +1,14 @@
+#!/usr/bin/perl
+#   The Computer Language Shootout
+#   http://shootout.alioth.debian.org/
+#   contributed by Cosimo Streppone
+
+use strict;
+my($nl, $nw, $nc);
+while (read(STDIN, $_, 4095)) {
+    $_ .= <STDIN>;
+    $nc += length;
+    $nw += scalar split;
+    $nl += tr/\n/\n/;
+}
+print "$nl $nw $nc\n";

data/sources/perl/wordfreq.perl

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+# $Id: wordfreq.perl,v 1.2 2004-07-03 05:36:11 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+
+# Tony Bowden suggested using tr versus lc and split(/[^a-z]/)
+# Some corrections to comply with tr/wc/sort "master" implementation
+
+use strict;
+
+my %count = ();
+while (read(STDIN, $_, 4095) and $_ .= <STDIN>) {
+    tr/A-Za-z/\n/cs;
+    ++$count{$_} foreach split('\n', lc $_);
+}
+
+my @lines = ();
+my ($w, $c);
+while (($w, $c) = each(%count)) {
+    next if ("$w" eq "");
+    push(@lines, sprintf("%7d %s\n", $c, $w));
+}
+print sort { $b cmp $a } @lines;

data/sources/python/ackermann.python

@@ -0,0 +1,21 @@
+#!/usr/bin/python
+# $Id: ackermann.python,v 1.3 2005-03-16 08:37:07 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# from Brad Knotwell
+
+import sys
+sys.setrecursionlimit(5000000)
+
+def Ack(M, N):
+    if (not M):
+        return( N + 1 )
+    if (not N):
+        return( Ack(M-1, 1) )
+    return( Ack(M-1, Ack(M, N-1)) )
+
+def main():
+    NUM = int(sys.argv[1])
+    sys.setrecursionlimit(10000)
+    print "Ack(3,%d): %d" % (NUM, Ack(3, NUM))
+
+main()

data/sources/python/ary.python

@@ -0,0 +1,19 @@
+#!/usr/bin/python
+# $Id: ary.python,v 1.2 2004-05-22 07:25:00 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from Brad Knotwell
+
+import sys
+
+def main():
+    n = int(sys.argv[1])
+    x = n * [0]       
+    y = n * [0]
+    for i in xrange(0,n):
+        x[i] = i + 1
+    for k in xrange(0,1000):
+        for i in xrange(n-1,-1,-1):
+            y[i] += x[i]
+    print y[0], y[-1]
+
+main()

data/sources/python/binarytrees.python

@@ -0,0 +1,39 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# contributed by Antoine Pitrou
+# modified by Dominique Wahli
+# modified by Heinrich Acker
+
+import sys, gc
+gc.disable()
+
+def make_tree(item, depth):
+    if not depth: return item, None, None
+    item2 = item + item
+    depth -= 1
+    return item, make_tree(item2 - 1, depth), make_tree(item2, depth)
+
+def check_tree((item, left, right)):
+    if not left: return item
+    return item + check_tree(left) - check_tree(right)
+
+min_depth = 4
+max_depth = max(min_depth + 2, int(sys.argv[1]))
+stretch_depth = max_depth + 1
+
+print "stretch tree of depth %d\t check:" % stretch_depth, check_tree(make_tree(0, stretch_depth))
+
+long_lived_tree = make_tree(0, max_depth)
+
+iterations = 2**max_depth
+for depth in xrange(min_depth, stretch_depth, 2):
+
+    check = 0
+    for i in xrange(1, iterations + 1):
+        check += check_tree(make_tree(i, depth)) + check_tree(make_tree(-i, depth))
+
+    print "%d\t trees of depth %d\t check:" % (iterations * 2, depth), check
+    iterations /= 4
+
+print "long lived tree of depth %d\t check:" % max_depth, check_tree(long_lived_tree)

data/sources/python/binarytrees.python-3.python

@@ -0,0 +1,44 @@
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org/
+#
+# contributed by Antoine Pitrou
+# modified by Dominique Wahli
+
+from sys import argv
+
+def make_tree(item, depth):
+    if depth > 0:
+        item2 = 2 * item
+        depth -= 1
+        return (item, make_tree(item2 - 1, depth), make_tree(item2, depth))
+    else:
+        return (item, None, None)
+
+def check_tree((item, left, right)):
+    if left is not None:
+        return item + check_tree(left) - check_tree(right)
+    else:
+        return item
+
+def main():
+    min_depth = 4
+    max_depth = max(min_depth + 2, int(argv[1]))
+    stretch_depth = max_depth + 1
+    
+    print "stretch tree of depth %d\t check: %d" % (stretch_depth, check_tree(make_tree(0, stretch_depth)))
+
+    long_lived_tree = make_tree(0, max_depth)
+    
+    for depth in xrange(min_depth, stretch_depth, 2):
+        iterations = 2**(max_depth - depth + min_depth)
+
+        check = 0
+        for i in xrange(1, iterations + 1):
+            check += check_tree(make_tree(i, depth)) + check_tree(make_tree(-i, depth))
+
+        print "%d\t trees of depth %d\t check: %d" % (iterations * 2, depth, check)
+
+    print "long lived tree of depth %d\t check: %d" % (max_depth, check_tree(long_lived_tree))
+
+if __name__ == '__main__':
+    main()

data/sources/python/chameneos.python-6.python

@@ -0,0 +1,73 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# contributed by Tobias Polzin, translated from Mike Pall's Lua program
+# modified by Josh Goldfoot to use ifs for the complement routine
+# modified by Heinrich Acker
+
+import sys
+
+N = int(sys.argv[1])
+first = second = None
+meetings = 0
+
+RED, BLUE, YELLOW = range(1,4)
+
+# Create a very social creature.
+def creature(me):
+    global N, first, second, meetings
+    met = 0
+    while 1:
+        # Meet another creature.
+
+        # Wait until meeting place clears.
+        while second:
+            yield None
+
+        other = first
+        if other:
+            # Hey, I found a new friend!
+            second = me
+        else:
+            # Sniff, nobody here (yet).
+            if N <= 0:
+                # Uh oh, the mall is closed.
+                meetings += met
+                yield None
+
+                # The mall was closed, so everyone is faded.
+                print meetings
+                sys.exit()
+
+            N -= 1
+            first = me
+            while not second:
+                yield None # Wait for another creature.
+            other = second
+
+            first = second = None
+            yield None
+
+        # perform meeting
+        met += 1
+        if me != other:
+            if me == BLUE:
+                me = other == RED and YELLOW or RED
+            elif me == RED:
+                me = other == BLUE and YELLOW or BLUE
+            else:
+                me = other == BLUE and RED or BLUE
+
+# Trivial round-robin scheduler.
+def schedule(threads):
+    while 1:
+        for thread in threads:
+            thread()
+
+# A bunch of colorful creatures.
+threads = [
+    creature(BLUE).next,
+    creature(RED).next,
+    creature(YELLOW).next,
+    creature(BLUE).next]
+
+schedule(threads)

data/sources/python/chameneosredux.python

@@ -0,0 +1,126 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+# contributed by Tupteq
+#
+# Based on codes from PDF and Nice #3 version.
+# Before use of threading.Condition I tried semaphores (code similar to
+# C code from PDF), but it was slower.
+
+from __future__ import with_statement  # Required until Python 2.6
+
+import sys
+from threading import Thread, Condition
+
+# Constatnts
+all_colors = blue, red, yellow = "blue", "red", "yellow"
+stop = 0, blue  # Stop condition
+
+
+def complement(c1, c2):
+    # I used 'is' except '==' here, it's faster
+    return (c1 if c1 is c2
+        else (yellow if c2 is red else red) if c1 is blue
+        else (yellow if c2 is blue else blue) if c1 is red
+        else (red if c2 is blue else blue))
+
+
+def print_color_changes():
+    # Print complement for each combination
+    for c1 in all_colors:
+        for c2 in all_colors:
+            print "%s + %s -> %s" % (c1, c2, complement(c1, c2))
+
+
+class Mall:
+    def __init__(self, n):
+        self.first = True
+        self.must_wait = False
+        self.counter = n
+        self.cond = Condition()
+
+    def notify(self, me):
+        # "with" makes all the job (no acquire() and release() needed)
+        with self.cond:
+            while self.must_wait and self.counter > 0:
+                self.cond.wait()
+
+            if self.first:
+                # Creature is first
+                self.a = me
+                self.first = False
+
+                while not self.first and self.counter > 0:
+                    self.cond.wait()
+
+                he = self.b
+                self.must_wait = False
+                self.cond.notifyAll()
+
+                self.counter -= 1
+            else:
+                # Creature is second
+                self.b = me
+                he = self.a
+                self.first = True
+                self.must_wait = True
+                self.cond.notifyAll()
+
+            return he if self.counter >= 0 else stop
+
+
+class Creature(Thread):
+    def __init__(self, name, color, mall):
+        # Thread initialization, thread built in name is not used
+        Thread.__init__(self)
+        self.name = name
+        self.color = color
+        self.mall = mall
+        self.self_met = 0
+        self.met = 0
+
+    def run(self):
+        while 1:
+            # Go to meeting place
+            his_name, his_color = self.mall.notify((self.name, self.color))
+            if his_name == 0:
+                break
+
+            # Change color and increment counters
+            self.color = complement(self.color, his_color)
+            if self.name is his_name:
+                self.self_met += 1
+            self.met += 1
+
+
+def simulate(colors, n):
+    # Prepare and execute simulation
+    r = Mall(n)
+    creatures = [Creature(i+1, color, r) for i, color in enumerate(colors)]
+    for c in creatures:
+        c.start()
+    for c in creatures:
+        c.join()
+
+    # Prepare spellout function
+    numbers = ("zero", "one", "two", "three", "four",
+        "five", "six", "seven", "eight", "nine")
+    def spellout(i):
+        return " " + " ".join(numbers[int(x)] for x in str(i))
+
+    # Print results
+    print
+    print " " + " ".join(colors)
+    sum = 0
+    for c in creatures:
+        sum += c.met
+        print str(c.met) + spellout(c.self_met)
+    print spellout(sum)
+
+
+def main():
+    n = int(sys.argv[1])
+    print_color_changes()
+    simulate([blue, red, yellow], n)
+    simulate([blue, red, yellow, red, yellow, blue, red, yellow, red, blue], n)
+
+main()