chrislo-sourceclassifier 0.2.0

data/sources/ruby/objinst.ruby

@@ -0,0 +1,58 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: objinst.ruby,v 1.1.1.1 2004-05-19 18:11:03 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from Aristarkh Zagorodnikov
+
+class Toggle
+    def initialize(start_state)
+	@bool = start_state
+    end
+
+    def value
+	@bool
+    end
+
+    def activate
+	@bool = !@bool
+	self
+    end
+end
+
+class NthToggle < Toggle
+    def initialize(start_state, max_counter)
+	super start_state
+	@count_max = max_counter
+	@counter = 0
+    end
+
+    def activate
+	@counter += 1
+	if @counter >= @count_max
+	    @bool = !@bool
+	    @counter = 0
+	end
+	self
+    end
+end
+
+n = (ARGV.shift || 1).to_i
+
+toggle = Toggle.new 1
+5.times do
+    puts toggle.activate.value ? 'true' : 'false'
+end
+n.times do
+    toggle = Toggle.new 1
+end
+
+puts
+
+ntoggle = NthToggle.new 1, 3
+8.times do
+    puts ntoggle.activate.value ? 'true' : 'false'
+end
+n.times do
+    ntoggle = NthToggle.new 1, 3
+end
+

data/sources/ruby/partialsums.ruby

@@ -0,0 +1,39 @@
+# ----------------------------------------------------------------------
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# Based on D language implementation by Dave Fladebo
+#
+# Contributed by Anthony Borla
+# ----------------------------------------------------------------------
+
+n = (ARGV.shift || 1).to_i
+
+alt = 1.0 ; s0 = s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = 0.0
+
+1.upto(n) do |d|
+  d = d.to_f ; d2 = d * d ; d3 = d2 * d ; ds = Math.sin(d) ; dc = Math.cos(d)
+
+  s0 += (2.0 / 3.0) ** (d - 1.0)
+  s1 += 1.0 / Math.sqrt(d)
+  s2 += 1.0 / (d * (d + 1.0))
+  s3 += 1.0 / (d3 * ds * ds)
+  s4 += 1.0 / (d3 * dc * dc)
+  s5 += 1.0 / d
+  s6 += 1.0 / d2
+  s7 += alt / d
+  s8 += alt / (2.0 * d - 1.0)
+
+  alt = -alt
+end
+
+printf("%.9f\t(2/3)^k\n", s0)
+printf("%.9f\tk^-0.5\n", s1)
+printf("%.9f\t1/k(k+1)\n", s2)
+printf("%.9f\tFlint Hills\n", s3)
+printf("%.9f\tCookson Hills\n", s4)
+printf("%.9f\tHarmonic\n", s5)
+printf("%.9f\tRiemann Zeta\n", s6)
+printf("%.9f\tAlternating Harmonic\n", s7)
+printf("%.9f\tGregory\n", s8)
+

data/sources/ruby/pidigits.ruby

@@ -0,0 +1,92 @@
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# contributed by Gabriele Renzi
+
+class PiDigitSpigot 
+ 
+    def initialize()
+        @z = Transformation.new 1,0,0,1
+        @x = Transformation.new 0,0,0,0
+        @inverse = Transformation.new 0,0,0,0
+    end
+
+    def next!
+        @y = @z.extract(3) 
+        if safe? @y
+            @z = produce(@y)
+            @y
+        else 
+            @z = consume @x.next!() 
+            next!()
+        end
+    end
+
+    def safe?(digit)
+        digit == @z.extract(4)
+    end
+
+    def produce(i)
+        @inverse.qrst(10,-10*i,0,1).compose(@z)
+    end
+
+    def consume(a)
+        @z.compose(a)
+    end
+end
+
+
+class Transformation 
+    attr_reader :q, :r, :s, :t
+    def initialize (q, r, s, t)
+        @q,@r,@s,@t,@k = q,r,s,t,0
+    end
+    
+    def next!()
+        @q = @k = @k + 1
+        @r = 4 * @k + 2
+        @s = 0
+        @t = 2 * @k + 1
+        self
+    end
+
+    def extract(j)
+        (@q * j + @r) / (@s * j + @t)
+    end
+    
+    def compose(a)
+        self.class.new( @q * a.q,
+                        @q * a.r + r * a.t,
+                        @s * a.q + t * a.s,
+                        @s * a.r + t * a.t
+                    ) 
+    end
+    
+    def qrst *args
+        initialize *args
+        self
+    end
+
+    
+end
+
+
+WIDTH = 10
+n = Integer(ARGV[0])
+j = 0
+
+digits = PiDigitSpigot.new
+
+while n > 0
+    if n >= WIDTH
+        WIDTH.times {print digits.next!}
+        j += WIDTH
+    else 
+        n.times {print digits.next!}
+        (WIDTH-n).times {print " "} 
+        j += n
+    end
+    puts "\t:"+j.to_s
+    n -= WIDTH
+end
+

data/sources/ruby/pidigits.ruby-2.ruby

@@ -0,0 +1,109 @@
+# The Computer Language Benchmarks Game
+# http://shootout.alioth.debian.org/
+#
+# Use libgmp-ruby_1.0 
+#
+# contributed by Gabriele Renzi
+# modified by Pilho Kim
+
+require 'gmp'
+
+class PiDigitSpigot
+    def initialize()
+        @ZERO = GMP::Z.new(0)
+        @ONE = GMP::Z.new(1)
+        @THREE = GMP::Z.new(3)
+        @FOUR = GMP::Z.new(4)
+        @TEN = GMP::Z.new(10)
+        @z = Transformation.new @ONE,@ZERO,@ZERO,@ONE
+        @x = Transformation.new @ZERO,@ZERO,@ZERO,@ZERO
+        @inverse = Transformation.new @ZERO,@ZERO,@ZERO,@ZERO
+    end
+
+    def next!
+        @y = @z.extract(@THREE)
+        if safe? @y
+            @z = produce(@y)
+            @y
+        else
+            @z = consume @x.next!()
+            next!()
+        end
+    end
+
+    def safe?(digit)
+        digit == @z.extract(@FOUR)
+    end
+
+    def produce(i)
+        @inverse.qrst(@TEN,-@TEN*i,@ZERO,@ONE).compose(@z)
+    end
+
+    def consume(a)
+        @z.compose(a)
+    end
+end
+
+
+class Transformation
+    attr_reader :q, :r, :s, :t
+    def initialize (q, r, s, t)
+        @ZERO = GMP::Z.new(0)
+        @ONE = GMP::Z.new(1)
+        @TWO = GMP::Z.new(2)
+        @FOUR = GMP::Z.new(4)
+        @q,@r,@s,@t,@k = q,r,s,t,@ZERO
+    end
+
+    def next!()
+        @q = @k = @k + @ONE
+        @r = @FOUR * @k + @TWO
+        @s = @ZERO
+        @t = @TWO * @k + @ONE
+        self
+    end
+
+    def extract(j)
+        (@q * j + @r).tdiv( @s * j + @t )
+    end
+
+    def compose(a)
+        self.class.new( @q * a.q,
+                        @q * a.r + r * a.t,
+                        @s * a.q + t * a.s,
+                        @s * a.r + t * a.t
+                    )
+    end
+
+    def qrst *args
+        initialize *args
+        self
+    end
+
+end
+
+
+@zero = GMP::Z.new(0)
+@one = GMP::Z.new(1)
+@two = GMP::Z.new(2)
+@four = GMP::Z.new(4)
+@ten = GMP::Z.new(10)
+
+WIDTH = 10
+n = Integer(ARGV[0] || "27")
+j = 0
+
+digits = PiDigitSpigot.new
+
+while n > 0
+    if n >= WIDTH
+        WIDTH.times {print digits.next!}
+        j += WIDTH
+    else
+        n.times {print digits.next!}
+        (WIDTH-n).times {print " "}
+        j += n
+    end
+    puts "\t:"+j.to_s
+    n -= WIDTH
+end

data/sources/ruby/prodcons.ruby

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: prodcons.ruby,v 1.3 2005-06-10 00:57:22 igouy-guest Exp $
+# http://www.bagley.org/~doug/shootout/
+
+require 'thread'
+
+def main(n)
+    mutex = Mutex.new
+    access = ConditionVariable.new
+    count = data = consumed = produced = 0
+    consumer = Thread.new do
+	i = 0
+	loop do
+	    mutex.synchronize {
+		while count == 0 do access.wait(mutex) end
+		i = data
+		count = 0
+		access.signal
+	    }
+	    consumed += 1
+	    if i == n then break end
+	end
+    end
+    producer = Thread.new do
+	for i in 1 .. n do
+	    mutex.synchronize {
+		while count == 1 do access.wait(mutex) end
+		data = i
+		count = 1
+		access.signal
+	    }
+	    produced += 1
+	end
+    end
+    producer.join
+    consumer.join
+    puts "#{produced} #{consumed}"
+end
+
+main(Integer(ARGV.shift || 1))

data/sources/ruby/random.ruby

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: random.ruby,v 1.1.1.1 2004-05-19 18:11:16 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+IM = 139968
+IA = 3877
+IC = 29573
+
+$last = 42.0
+def gen_random (max) (max * ($last = ($last * IA + IC) % IM)) / IM end
+
+N = Integer(ARGV.shift || 1) - 1
+N.times do
+    gen_random(100.0)
+end
+printf "%.9f\n", gen_random(100.0)

data/sources/ruby/recursive.ruby-2.ruby

@@ -0,0 +1,53 @@
+# ----------------------------------------------------------------------
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# Code based on / inspired by existing, relevant Shootout submissions
+#
+# Contributed by Anthony Borla
+# Optimized by Jesse Millikan
+# ----------------------------------------------------------------------
+
+def ack(m, n)
+  if m == 0 then 
+    n + 1
+  else if n == 0 then
+    ack(m - 1, 1)
+   else 
+     ack(m - 1, ack(m, n - 1))
+   end
+  end
+end
+
+# ---------------------------------
+
+def fib(n)
+   if n > 1 then
+     fib(n - 2) + fib(n - 1) 
+   else 
+     1
+   end
+end
+
+# ---------------------------------
+
+def tak(x, y, z)
+  if y < x then
+   tak(tak(x - 1.0, y, z), tak(y - 1.0, z, x), tak(z - 1.0, x, y))
+  else z
+  end
+end
+
+# ---------------------------------
+
+n = (ARGV.shift || 1).to_i
+
+printf("Ack(3,%d): %d\n", n, ack(3, n));
+printf("Fib(%.1f): %.1f\n", 27.0 + n, fib(27.0 + n));
+
+n -= 1;
+printf("Tak(%d,%d,%d): %d\n", n * 3, n * 2, n, tak(n * 3, n * 2, n));
+
+printf("Fib(3): %d\n", fib(3));
+printf("Tak(3.0,2.0,1.0): %.1f\n", tak(3.0, 2.0, 1.0));
+

data/sources/ruby/regexdna.ruby

@@ -0,0 +1,32 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# contributed by jose fco. gonzalez
+seq = STDIN.readlines.join
+ilen = seq.size
+
+seq.gsub!(/>.*\n|\n/,"")
+clen = seq.length
+
+[
+  /agggtaaa|tttaccct/i,
+  /[cgt]gggtaaa|tttaccc[acg]/i,
+  /a[act]ggtaaa|tttacc[agt]t/i,
+  /ag[act]gtaaa|tttac[agt]ct/i,
+  /agg[act]taaa|ttta[agt]cct/i,
+  /aggg[acg]aaa|ttt[cgt]ccct/i,
+  /agggt[cgt]aa|tt[acg]accct/i,
+  /agggta[cgt]a|t[acg]taccct/i,
+  /agggtaa[cgt]|[acg]ttaccct/i
+].each {|f| puts "#{f.source} #{seq.scan(f).size}" }
+
+{
+'B' => '(c|g|t)', 'D' => '(a|g|t)', 'H' => '(a|c|t)', 'K' => '(g|t)',
+'M' => '(a|c)', 'N' => '(a|c|g|t)', 'R' => '(a|g)', 'S' => '(c|t)',
+'V' => '(a|c|g)', 'W' => '(a|t)', 'Y' => '(c|t)'
+}.each { |f,r| seq.gsub!(f,r) }
+
+puts
+puts ilen
+puts clen
+puts seq.length