chrislo-sourceclassifier 0.2.0 → 0.2.1

data/sources/ruby/objinst.ruby

@@ -1,58 +0,0 @@
-#!/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

@@ -1,39 +0,0 @@
-# ----------------------------------------------------------------------
-# 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

@@ -1,92 +0,0 @@
-# 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

@@ -1,109 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-#!/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

@@ -1,17 +0,0 @@
-#!/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

@@ -1,53 +0,0 @@
-# ----------------------------------------------------------------------
-# 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

@@ -1,32 +0,0 @@
-# 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