chrislo-sourceclassifier 0.2.0

data/sources/ruby/binarytrees.ruby-2.ruby

@@ -0,0 +1,55 @@
+# The Computer Language Shootout Benchmarks
+# http://shootout.alioth.debian.org
+#
+# contributed by Jesse Millikan
+
+def item_check(tree)
+ if tree[0] == nil
+  tree[1]
+ else
+  tree[1] + item_check(tree[0]) - item_check(tree[2])
+ end
+end
+
+def bottom_up_tree(item, depth)
+ if depth > 0
+  item_item = 2 * item
+  depth -= 1
+  [bottom_up_tree(item_item - 1, depth), item, bottom_up_tree(item_item, depth)]
+ else
+  [nil, item, nil]
+ end
+end
+
+max_depth = ARGV[0].to_i
+min_depth = 4
+
+max_depth = min_depth + 2 if min_depth + 2 > max_depth
+
+stretch_depth = max_depth + 1
+stretch_tree = bottom_up_tree(0, stretch_depth)
+
+puts "stretch tree of depth #{stretch_depth}\t check: #{item_check(stretch_tree)}"
+stretch_tree = nil
+
+long_lived_tree = bottom_up_tree(0, max_depth)
+
+min_depth.step(max_depth + 1, 2) do |depth|
+ iterations = 2**(max_depth - depth + min_depth)
+
+ check = 0
+
+ for i in 1..iterations
+  temp_tree = bottom_up_tree(i, depth)
+  check += item_check(temp_tree)
+
+  temp_tree = bottom_up_tree(-i, depth)
+  check += item_check(temp_tree)
+ end
+
+ puts "#{iterations * 2}\t trees of depth #{depth}\t check: #{check}"
+end
+
+puts "long lived tree of depth #{max_depth}\t check: #{item_check(long_lived_tree)}"
+
+

data/sources/ruby/chameneos.ruby-2.ruby

@@ -0,0 +1,71 @@
+#########################################
+#     The Computer Language Shootout    #
+#   http://shootout.alioth.debian.org/  #
+#                                       #
+#      Contributed by Jesse Millikan    #
+#    Based on version by Gordon Innes   #
+#########################################
+
+require 'thread'
+
+creature_meetings = Queue.new
+meeting_point = Mutex.new
+wait_signal = ConditionVariable.new
+meetings_left = ARGV[0].to_i
+waiting_colour, incoming_colour = nil, nil
+
+# Each chameneo is represented here by a thread
+# and its colour variable, rather than explicitly
+# by an object
+#
+# This is all packed into one place for speed and
+# clarity (It's clear to *me* :)
+[:blue, :red, :yellow, :blue].each { |colour|
+  Thread.new {
+    met = 0
+    while true
+      # The form meeting_point.synchronize { } is slow
+      meeting_point.lock
+
+      if meetings_left <= 0
+        meeting_point.unlock
+	# colour = :faded
+	break 
+      end
+
+      # Both threads emerge with variable other_colour set
+      if waiting_colour
+        other_colour = waiting_colour
+        incoming_colour = colour
+        wait_signal.signal
+        meetings_left-=1
+        waiting_colour = nil
+      else
+        waiting_colour = colour
+        wait_signal.wait(meeting_point)
+        other_colour = incoming_colour
+      end
+      meeting_point.unlock
+
+      met += 1
+
+      # Take the complement colour
+      colour = 
+        case other_colour
+          when :blue
+           colour == :red ? :yellow : :red
+          when :red
+           colour == :blue ? :yellow : :blue
+          when :yellow
+           colour == :blue ? :red : :blue
+        end
+    end
+
+    # Leave the total on the queue for the main thread
+    creature_meetings.push(met)
+  }
+}
+
+total = 0
+4.times { total += creature_meetings.pop }
+puts total

data/sources/ruby/dispatch.ruby

@@ -0,0 +1,114 @@
+#!/usr/bin/ruby
+#
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org
+# 
+# contributed by Jesse Millikan
+
+class BottleState
+ attr_reader :tag
+ private_class_method :new
+
+ def initialize(tag)
+  @tag = tag
+ end
+
+ def BottleState.initial; @@empty; end
+
+ def BottleState.pressurized_initial; @@unpressurized_empty; end
+
+# Thanks to dbrock on #ruby-lang on freenode for some tips on this.
+
+ @@empty = new(1)
+
+ def @@empty.next(bottle); bottle.state = @@full; end
+
+ @@full = new(2)
+ 
+ def @@full.next(bottle); bottle.state = @@sealed; end
+
+ @@sealed = new(3)
+
+ def @@sealed.next(bottle); bottle.state = @@empty; end
+
+ @@unpressurized_empty = new(4)
+
+ def @@unpressurized_empty.next(bottle); bottle.state = @@unpressurized_full; end
+
+ @@unpressurized_full = new(5)
+ 
+ def @@unpressurized_full.next(bottle); bottle.state = @@pressurized_unsealed; end
+
+ @@pressurized_unsealed = new(6)
+ 
+ def @@pressurized_unsealed.next(bottle); bottle.state = @@pressurized_sealed; end
+
+ @@pressurized_sealed = new(7)
+ 
+ def @@pressurized_sealed.next(bottle); bottle.state = @@unpressurized_empty; end
+end
+
+#Someone with judgement on style could pare this down a bit.
+class Bottle
+  attr_writer :state
+
+ def initialize(id)
+  @id = id
+  @state = initial
+ end
+
+ def initial; BottleState.initial; end
+
+ def cycle; fill; seal; empty; end
+ 
+ def next; @state.next(self); end
+
+ alias_method :empty, :next
+ alias_method :fill, :next
+ alias_method :seal, :next
+
+ def check(c); @state.tag + @id + c; end
+end
+
+class PressurizedBottle < Bottle
+ def initial; BottleState.pressurized_initial; end
+ 
+ alias_method :pressurize, :next
+
+ def cycle; fill; pressurize; seal; empty; end
+end
+
+def bottle_check(a1, a2, a3, a4, a5, i)
+ a1.cycle; a2.cycle; a3.cycle; a4.cycle; a5.cycle
+
+ c = i % 2
+
+ a1.check(c) + a2.check(c) + a3.check(c) + a4.check(c) + a5.check(c)
+end
+
+n = 0
+n = ARGV[0].to_i unless ARGV.empty?
+
+b1 = Bottle.new(1); b2 = Bottle.new(2)
+b3 = Bottle.new(3); b4 = Bottle.new(4)
+b5 = Bottle.new(5); b6 = Bottle.new(6)
+b7 = Bottle.new(7); b8 = Bottle.new(8)
+b9 = Bottle.new(9); b0 = Bottle.new(0)
+
+p1 = PressurizedBottle.new(1); p2 = PressurizedBottle.new(2)
+p3 = PressurizedBottle.new(3); p4 = PressurizedBottle.new(4)
+p5 = PressurizedBottle.new(5); p6 = PressurizedBottle.new(6)
+p7 = PressurizedBottle.new(7); p8 = PressurizedBottle.new(8)
+p9 = PressurizedBottle.new(9); p0 = PressurizedBottle.new(0)
+
+check = 0
+
+for i in 1..n
+ check += bottle_check(b1, b2, b3, b4, b5, i)
+ check += bottle_check(b6, b7, b8, b9, b0, i)
+
+ check += bottle_check(p1, p2, p3, p4, p5, i)
+ check -= bottle_check(p6, p7, p8, p9, p0, i)
+end
+
+puts "#{check}"

data/sources/ruby/echo.ruby

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: echo.ruby,v 1.1.1.1 2004-05-19 18:09:37 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+require "socket"
+
+DATA = "Hello there sailor\n"
+
+def echo_client(n, port)
+    sock = TCPsocket.open('127.0.0.1', port)
+    n.times do
+	sock.write(DATA)
+	ans = sock.readline
+	if ans != DATA then
+	    raise sprintf("client: \"%s\" \"%s\"", DATA, ans)
+	end
+    end
+    sock.close
+end
+
+
+def echo_server(n)
+    ssock = TCPserver.open('127.0.0.1', 0)
+    port = ssock.addr[1]
+    if pid = fork then
+	# parent is server
+	csock = ssock.accept
+	n = 0
+	while str = csock.gets
+	    n += csock.write(str)
+	end
+	Process.wait
+        printf "server processed %d bytes\n", n
+    else
+	# child is client
+	echo_client(n, port)
+    end
+end
+
+echo_server(Integer(ARGV.shift || 1))

data/sources/ruby/except.ruby

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: except.ruby,v 1.1.1.1 2004-05-19 18:09:43 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+$HI = 0
+$LO = 0
+NUM = Integer(ARGV[0] || 1)
+
+
+class Lo_Exception < Exception
+    def initialize(num)
+        @value = num
+        return self
+    end
+end
+
+class Hi_Exception < Exception
+    def initialize(num)
+        @value = num
+        return self
+    end
+end
+
+def some_function(num)
+    begin
+	hi_function(num)
+    rescue
+        print "We shouldn't get here, exception is: #{$!.type}\n"
+    end
+end
+
+def hi_function(num)
+    begin
+	lo_function(num)
+    rescue Hi_Exception
+	$HI = $HI + 1
+    end
+end
+
+def lo_function(num)
+    begin
+	blowup(num)
+    rescue Lo_Exception
+	$LO = $LO + 1
+    end
+end
+
+def blowup(num)
+    if num % 2 == 0
+	raise Lo_Exception.new(num)
+    else
+	raise Hi_Exception.new(num)
+    end
+end
+
+
+for iter in 1 .. NUM
+    some_function(iter)
+end
+print "Exceptions: HI=", $HI, " / LO=", $LO, "\n"

data/sources/ruby/except.ruby-2.ruby

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: except.ruby-2.ruby,v 1.1 2004-11-10 06:26:50 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+
+$HI = 0
+$LO = 0
+NUM = Integer(ARGV[0] || 1)
+
+
+class Lo_Exception < Exception
+    def initialize(num)
+        @value = num
+        return self
+    end
+end
+
+class Hi_Exception < Exception
+    def initialize(num)
+        @value = num
+        return self
+    end
+end
+
+def some_function(num)
+    begin
+	hi_function(num)
+    rescue
+        print "We shouldn't get here, exception is: #{$!.type}\n"
+    end
+end
+
+def hi_function(num)
+    begin
+	lo_function(num)
+    rescue Hi_Exception
+	$HI = $HI + 1
+    end
+end
+
+def lo_function(num)
+    begin
+	blowup(num)
+    rescue Lo_Exception
+	$LO = $LO + 1
+    end
+end
+
+def blowup(num)
+    if num & 2 == 0
+	raise Lo_Exception.new(num)
+    else
+	raise Hi_Exception.new(num)
+    end
+end
+
+
+for iter in 1 .. NUM
+    some_function(iter)
+end
+print "Exceptions: HI=", $HI, " / LO=", $LO, "\n"

data/sources/ruby/fannkuch.ruby

@@ -0,0 +1,42 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+# Contributed by Sokolov Yura
+# Modified by Ryan Williams
+
+def fannkuch(n)
+   maxFlips, m, r, check = 0, n-1, n, 0
+   count = (1..n).to_a
+   perm = (1..n).to_a
+
+   while true
+      if check < 30
+         puts "#{perm}"
+         check += 1
+      end
+
+      while r != 1:
+         count[r-1] = r
+         r -= 1
+      end
+
+      if perm[0] != 1 and perm[m] != n
+         perml = perm.clone #.dup
+         flips = 0
+         while (k = perml.first ) != 1
+            perml = perml.slice!(0, k).reverse + perml
+            flips += 1
+         end
+         maxFlips = flips if flips > maxFlips
+      end
+      while true
+         if r==n : return maxFlips end
+         perm.insert r,perm.shift
+         break if (count[r] -= 1) > 0
+         r += 1
+      end
+   end
+end
+
+N = (ARGV[0] || 1).to_i
+puts "Pfannkuchen(#{N}) = #{fannkuch(N)}"
+