chrislo-sourceclassifier 0.2.0

data/sources/ruby/fasta.ruby

@@ -0,0 +1,81 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+# Contributed by Sokolov Yura
+
+$last = 42.0
+def gen_random (max,im=139968,ia=3877,ic=29573) 
+    (max * ($last = ($last * ia + ic) % im)) / im
+end
+
+alu = 
+   "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"+
+   "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"+
+   "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"+
+   "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"+
+   "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"+
+   "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"+
+   "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
+
+iub = [
+    ["a", 0.27],
+    ["c", 0.12],
+    ["g", 0.12],
+    ["t", 0.27],
+
+    ["B", 0.02],
+    ["D", 0.02],
+    ["H", 0.02],
+    ["K", 0.02],
+    ["M", 0.02],
+    ["N", 0.02],
+    ["R", 0.02],
+    ["S", 0.02],
+    ["V", 0.02],
+    ["W", 0.02],
+    ["Y", 0.02],
+]
+homosapiens = [
+    ["a", 0.3029549426680],
+    ["c", 0.1979883004921],
+    ["g", 0.1975473066391],
+    ["t", 0.3015094502008],
+]
+
+def make_repeat_fasta(id, desc, src, n)
+    puts ">#{id} #{desc}"
+    v = nil
+    width = 60
+    l = src.length
+    s = src * ((n / l) + 1)
+    s.slice!(n, l)
+    puts (s.scan(/.{1,#{width}}/).join("\n"))
+end
+
+def make_random_fasta(id, desc, table, n)
+    puts ">#{id} #{desc}"
+    rand, v = nil,nil
+    width = 60
+    chunk = 1 * width
+    prob = 0.0
+    table.each{|v| v[1]= (prob += v[1])}
+    for i in 1..(n/width)
+        puts (1..width).collect{
+            rand = gen_random(1.0)
+            table.find{|v| v[1]>rand}[0]
+        }.join
+    end
+    if n%width != 0
+        puts (1..(n%width)).collect{
+            rand = gen_random(1.0)
+            table.find{|v| v[1]>rand}[0]
+        }.join
+    end
+end
+
+
+n = (ARGV[0] or 27).to_i 
+
+make_repeat_fasta('ONE', 'Homo sapiens alu', alu, n*2)
+make_random_fasta('TWO', 'IUB ambiguity codes', iub, n*3)
+make_random_fasta('THREE', 'Homo sapiens frequency', homosapiens, n*5)
+

data/sources/ruby/fibo.ruby

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: fibo.ruby,v 1.3 2005-04-25 19:01:38 igouy-guest Exp $
+# http://www.bagley.org/~doug/shootout/
+
+def fib(n)
+    if n < 2 then
+	   1
+    else
+	   fib(n-2) + fib(n-1)
+    end
+end
+
+N = Integer(ARGV.shift || 1)
+puts fib(N)

data/sources/ruby/harmonic.ruby-2.ruby

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+# http://shootout.alioth.debian.org/
+#
+# Contributed by Christopher Williams
+# modified by Daniel South
+# modified by Doug King
+
+n = (ARGV[0] || 10000000).to_i
+
+partialSum = 0.0
+for i in (1..n)
+  partialSum += (1.0 / i)
+end
+
+printf("%.9f\n", partialSum)

data/sources/ruby/hash.ruby

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: hash.ruby,v 1.1.1.1 2004-05-19 18:09:55 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# with help from Aristarkh A Zagorodnikov
+
+n = (ARGV.shift || 1).to_i
+
+hash = {}
+for i in 1..n
+    hash['%x' % i] = 1
+end
+
+c = 0
+n.downto 1 do |i|
+    c += 1 if hash.has_key? i.to_s
+end
+
+puts c

data/sources/ruby/hash2.ruby

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: hash2.ruby,v 1.2 2004-11-10 06:36:29 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+# Revised by Dave Anderson
+
+n = Integer(ARGV.shift || 1)
+
+hash1 = {}
+i = 0
+for i in 0 .. 9999
+    hash1["foo_" << i.to_s] = i
+end
+
+hash2 = Hash.new(0)
+n.times do
+    for i in hash1.keys
+	hash2[i] += hash1[i]
+    end
+end
+
+printf "%d %d %d %d\n",
+    hash1["foo_1"], hash1["foo_9999"], hash2["foo_1"], hash2["foo_9999"]

data/sources/ruby/heapsort.ruby

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: heapsort.ruby,v 1.5 2005-04-14 15:59:37 igouy-guest Exp $
+#
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# modified by Jabari Zakiya
+
+IM = 139968
+IA =   3877
+IC =  29573
+
+$last = 42.0
+def gen_random (max) (max * ($last = ($last * IA + IC) % IM)) / IM end
+
+def heapsort(n, ra)
+    j = i = rra = 0
+    l = (n >> 1) + 1
+    ir = n - 1
+
+    while (1) do
+	if (l > 1) then
+	    rra = ra.at(l -= 1)
+	else
+	    rra = ra.at(ir)
+	    ra[ir] = ra.at(1)
+	    if ((ir -= 1) == 1) then
+		ra[1] = rra
+		return
+	    end
+	end
+	i = l
+	j = l << 1
+	while (j <= ir) do
+	    if ((j < ir) and (ra.at(j) < ra.at(j+1))) then
+		j += 1
+	    end
+	    if (rra < ra.at(j)) then
+		ra[i] = ra.at(j)
+		j += (i = j)
+	    else
+		j = ir + 1
+	    end
+	end
+	ra[i] = rra
+    end
+end
+
+N = Integer(ARGV.shift || 1)
+ary = Array.new(N) { gen_random(1.0) }
+
+heapsort(N, ary)
+
+printf "%.10f\n", ary.last

data/sources/ruby/hello.ruby

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: hello.ruby,v 1.1.1.1 2004-05-19 18:10:16 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+
+puts "hello world"

data/sources/ruby/knucleotide.ruby-2.ruby

@@ -0,0 +1,44 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org
+#
+# contributed by jose fco. gonzalez
+# modified by Sokolov Yura
+
+seq = String.new
+
+def frecuency( seq,length )
+    n, table = seq.length - length + 1, Hash.new(0)
+    f, i = nil, nil
+    (0 ... length).each do |f|
+        (f ... n).step(length) do |i|
+            table[seq[i,length]] += 1
+        end
+    end
+    [n,table]
+
+end
+
+def sort_by_freq( seq,length )
+    n,table = frecuency( seq,length )
+    a, b, v = nil, nil, nil
+    table.sort{|a,b| b[1] <=> a[1]}.each do |v|
+        puts "%s %.3f" % [v[0].upcase,((v[1]*100).to_f/n)]
+    end
+    puts
+end
+
+def find_seq( seq,s )
+    n,table = frecuency( seq,s.length )
+    puts "#{table[s].to_s}\t#{s.upcase}"
+end
+
+line = STDIN.gets while line !~ /^>THREE/
+line = STDIN.gets
+while (line !~ /^>/) & line do
+    seq << line.chomp
+    line = STDIN.gets
+end
+
+[1,2].each {|i| sort_by_freq( seq,i ) }
+
+%w(ggt ggta ggtatt ggtattttaatt ggtattttaatttatagt).each{|s| find_seq( seq,s) }

data/sources/ruby/lists.ruby

@@ -0,0 +1,46 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: lists.ruby,v 1.3 2005-06-10 16:59:56 igouy-guest Exp $
+# http://www.bagley.org/~doug/shootout/
+
+NUM = Integer(ARGV.shift || 1)
+
+SIZE = 10000
+
+def test_lists()
+    # create a list of integers (Li1) from 1 to SIZE
+    li1 = (1..SIZE).to_a
+    # copy the list to li2 (not by individual items)
+    li2 = li1.dup
+    # remove each individual item from left side of li2 and
+    # append to right side of li3 (preserving order)
+    li3 = Array.new
+    while (not li2.empty?)
+	li3.push(li2.shift)
+    end
+    # li2 must now be empty
+    # remove each individual item from right side of li3 and
+    # append to right side of li2 (reversing list)
+    while (not li3.empty?)
+	li2.push(li3.pop)
+    end
+    # li3 must now be empty
+    # reverse li1 in place
+    li1.reverse!
+    # check that first item is now SIZE
+    if li1[0] != SIZE then
+	p "not SIZE"
+	return(0)
+    end
+    # compare li1 and li2 for equality
+    if li1 != li2 then
+	return(0)
+    end
+    # return the length of the list
+    return(li1.length)
+end
+
+for iter in 1 .. NUM
+    result = test_lists()
+end
+print result, "\n"

data/sources/ruby/mandelbrot.ruby-3.ruby

@@ -0,0 +1,63 @@
+#  The Computer Language Benchmarks Game
+#  http://shootout.alioth.debian.org/
+#
+#  contributed by Karl von Laudermann
+#  modified by Jeremy Echols
+#  modified by Detlef Reichl
+
+size = ARGV[0].to_i
+
+puts "P4\n#{size} #{size}"
+
+ITER = 50                           # Iterations
+LIMIT_SQUARED = 4.0                 # Presquared limit
+
+byte_acc = 0
+bit_num = 0
+
+count_size = size - 1               # Precomputed size for easy for..in looping
+
+# For..in loops are faster than .upto, .downto, .times, etc.
+# That's not true, but left it here
+for y in 0..count_size
+  for x in 0..count_size
+    zr = 0.0
+    zi = 0.0
+    cr = (2.0*x/size)-1.5
+    ci = (2.0*y/size)-1.0
+    escape = false
+
+    zrzr = zr*zr
+    zizi = zi*zi
+    ITER.times do
+      tr = zrzr - zizi + cr
+      ti = 2.0*zr*zi + ci
+      zr = tr
+      zi = ti
+      # preserve recalculation
+      zrzr = zr*zr
+      zizi = zi*zi
+      if zrzr+zizi > LIMIT_SQUARED
+        escape = true
+        break
+      end
+    end
+
+    byte_acc = (byte_acc << 1) | (escape ? 0b0 : 0b1)
+    bit_num += 1
+
+    # Code is very similar for these cases, but using separate blocks
+    # ensures we skip the shifting when it's unnecessary, which is most cases.
+    if (bit_num == 8)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    elsif (x == count_size)
+      byte_acc <<= (8 - bit_num)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    end
+  end
+end
+

data/sources/ruby/matrix.ruby

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: matrix.ruby,v 1.2 2005-03-23 06:11:41 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+#
+# Contributed by Christopher Williams
+
+n = (ARGV[0] || 60).to_i
+size = 30
+
+def mkmatrix(rows, cols)
+  count = 0
+  Array.new(rows) do |i| 
+    Array.new(cols) {|j| count +=1 }
+  end
+end
+
+def mmult(rows, cols, m1, m2)
+  m3 = []
+  for i in 0 .. (rows - 1)
+    row = []
+    for j in 0 .. (cols - 1)
+      val = 0
+      for k in 0 .. (cols - 1)
+        val += m1[i][k] * m2[k][j]
+      end
+      row << val
+    end
+    m3 << row
+  end
+  m3
+end
+
+m1 = mkmatrix(size, size)
+m2 = mkmatrix(size, size)
+mm = []
+n.times do
+  mm = mmult(size, size, m1, m2)
+end
+puts "#{mm[0][0]} #{mm[2][3]} #{mm[3][2]} #{mm[4][4]}"

data/sources/ruby/matrix.ruby-2.ruby

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: matrix.ruby-2.ruby,v 1.1 2005-03-23 06:11:41 bfulgham Exp $
+# http://shootout.alioth.debian.org/
+#
+# Contributed by Christopher Williams
+
+n = (ARGV[0] || 60).to_i
+size = 30
+require 'matrix'
+n = (ARGV[0] || 600).to_i
+size = 30
+
+def mkmatrix(rows,cols)
+  count = 0
+  the_rows = Array.new(rows) do |i| 
+    Array.new(cols) {|j| count +=1 }
+  end
+  Matrix[*the_rows]
+end
+
+m1 = mkmatrix(size,size)
+m2 = mkmatrix(size,size)
+mm = []
+n.times do
+  mm = m1 * m2
+end
+puts "#{mm[0,0]} #{mm[2,3]} #{mm[3,2]} #{mm[4,4]}"
+
+