chrislo-sourceclassifier 0.2.0

data/sources/ruby/methcall.ruby

@@ -0,0 +1,58 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: methcall.ruby,v 1.1.1.1 2004-05-19 18:10:41 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
+
+def main()
+    n = Integer(ARGV.shift || 1)
+
+    val = 1
+    toggle = Toggle.new(val)
+    n.times do
+	val = toggle.activate().value()
+    end
+    if val then puts "true" else puts "false" end
+
+    val = 1
+    ntoggle = NthToggle.new(val, 3)
+    n.times do
+	val = ntoggle.activate().value()
+    end
+    if val then puts "true" else puts "false" end
+end
+
+main()
+

data/sources/ruby/methcall.ruby-2.ruby

@@ -0,0 +1,54 @@
+#!/usr/bin/tclsh
+# $Id: methcall.ruby-2.ruby,v 1.1 2005-04-16 15:11:10 igouy-guest Exp $
+
+# The Great Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# Contributed by Hemang Lavana
+# This program is based on object.tcl
+
+package require Itcl
+
+::itcl::class Toggle {
+    variable _state
+    constructor {start_state} {set _state $start_state}
+    public method value {} { return [expr {$_state ? true : false}]}
+    public method activate {} { 
+        set _state [expr {!$_state}] 
+        return $this
+    }
+}
+
+::itcl::class NthToggle {
+    inherit Toggle
+    variable _counter
+    variable _count_max
+
+    constructor {start_state max_counter} {Toggle::constructor $start_state} {
+        set _counter 0
+        set _count_max $max_counter
+    }
+    method activate {} {
+        incr _counter 1
+        if {$_counter >= $_count_max} {
+            set _state [expr {!$_state}]
+            set _counter 0
+        }
+        return $this
+    }
+}
+
+proc main {n} {
+    Toggle toggle TRUE
+    for {set i 0} {$i<$n} {incr i} {
+        set value [[toggle activate] value]
+    }
+    puts $value
+
+    NthToggle ntoggle TRUE 3
+    for {set i 0} {$i<$n} {incr i} {
+        set value [[ntoggle activate] value]
+    }
+    puts $value
+}
+main [lindex $argv 0]

data/sources/ruby/moments.ruby

@@ -0,0 +1,64 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: moments.ruby,v 1.2 2005-06-10 00:57:22 igouy-guest Exp $
+# http://www.bagley.org/~doug/shootout/ 
+
+# throw away unused parameter sent by benchmark framework
+ARGV.shift()
+
+def main ()
+    sum = 0.0
+    nums = []
+    num = nil
+
+    for line in STDIN.readlines()
+	num = Float(line)
+	nums << num
+	sum += num
+    end
+
+    n = nums.length()
+    mean = sum/n;
+    deviation = 0.0
+    average_deviation = 0.0
+    standard_deviation = 0.0
+    variance = 0.0
+    skew = 0.0
+    kurtosis = 0.0
+    
+    for num in nums
+	deviation = num - mean
+	average_deviation += deviation.abs()
+	variance += deviation**2;
+	skew += deviation**3;
+	kurtosis += deviation**4
+    end
+    average_deviation /= n
+    variance /= (n - 1)
+    standard_deviation = Math.sqrt(variance)
+
+    if (variance > 0.0)
+	skew /= (n * variance * standard_deviation)
+	kurtosis = kurtosis/(n * variance * variance) - 3.0
+    end
+
+    nums.sort()
+    mid = n / 2
+    
+    if (n % 2) == 0
+	median = (nums.at(mid) + nums.at(mid-1))/2
+    else
+	median = nums.at(mid)
+    end
+    
+    printf("n:                  %d\n", n)
+    printf("median:             %f\n", median)
+    printf("mean:               %f\n", mean)
+    printf("average_deviation:  %f\n", average_deviation)
+    printf("standard_deviation: %f\n", standard_deviation)
+    printf("variance:           %f\n", variance)
+    printf("skew:               %f\n", skew)
+    printf("kurtosis:           %f\n", kurtosis)
+end
+
+main()

data/sources/ruby/nbody.ruby-2.ruby

@@ -0,0 +1,145 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org
+#
+# Optimized for Ruby by Jesse Millikan
+# From version ported by Michael Neumann from the C gcc version, 
+# which was written by Christoph Bauer. 
+
+SOLAR_MASS = 4 * Math::PI**2
+DAYS_PER_YEAR = 365.24
+
+class Planet
+ attr_accessor :x, :y, :z, :vx, :vy, :vz, :mass
+
+ def initialize(x, y, z, vx, vy, vz, mass)
+  @x, @y, @z = x, y, z
+  @vx, @vy, @vz = vx * DAYS_PER_YEAR, vy * DAYS_PER_YEAR, vz * DAYS_PER_YEAR 
+  @mass = mass * SOLAR_MASS
+ end
+
+ def move_from_i(bodies, nbodies, dt, i)
+  while i < nbodies
+   b2 = bodies[i]
+   dx = @x - b2.x
+   dy = @y - b2.y
+   dz = @z - b2.z
+
+   distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
+   mag = dt / (distance * distance * distance)
+   b_mass_mag, b2_mass_mag = @mass * mag, b2.mass * mag
+
+   @vx -= dx * b2_mass_mag
+   @vy -= dy * b2_mass_mag
+   @vz -= dz * b2_mass_mag
+   b2.vx += dx * b_mass_mag
+   b2.vy += dy * b_mass_mag
+   b2.vz += dz * b_mass_mag
+   i += 1 
+  end
+
+  @x += dt * @vx
+  @y += dt * @vy
+  @z += dt * @vz
+ end
+end
+
+def energy(bodies)
+  e = 0.0
+  nbodies = bodies.size
+ 
+  for i in 0 ... nbodies 
+    b = bodies[i]
+    e += 0.5 * b.mass * (b.vx * b.vx + b.vy * b.vy + b.vz * b.vz)
+    for j in (i + 1) ... nbodies
+      b2 = bodies[j]
+      dx = b.x - b2.x
+      dy = b.y - b2.y
+      dz = b.z - b2.z
+      distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
+      e -= (b.mass * b2.mass) / distance
+    end
+  end
+  e
+end
+
+def offset_momentum(bodies)
+  px, py, pz = 0.0, 0.0, 0.0
+
+  for b in bodies
+    m = b.mass
+    px += b.vx * m
+    py += b.vy * m
+    pz += b.vz * m
+  end
+
+  b = bodies[0]
+  b.vx = - px / SOLAR_MASS
+  b.vy = - py / SOLAR_MASS
+  b.vz = - pz / SOLAR_MASS
+end
+
+BODIES = [
+  # sun
+  Planet.new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
+
+  # jupiter
+  Planet.new(
+    4.84143144246472090e+00,
+    -1.16032004402742839e+00,
+    -1.03622044471123109e-01,
+    1.66007664274403694e-03,
+    7.69901118419740425e-03,
+    -6.90460016972063023e-05,
+    9.54791938424326609e-04),
+
+  # saturn
+  Planet.new(
+    8.34336671824457987e+00,
+    4.12479856412430479e+00,
+    -4.03523417114321381e-01,
+    -2.76742510726862411e-03,
+    4.99852801234917238e-03,
+    2.30417297573763929e-05,
+    2.85885980666130812e-04),
+
+  # uranus
+  Planet.new(
+    1.28943695621391310e+01,
+    -1.51111514016986312e+01,
+    -2.23307578892655734e-01,
+    2.96460137564761618e-03,
+    2.37847173959480950e-03,
+    -2.96589568540237556e-05,
+    4.36624404335156298e-05),
+
+  # neptune
+  Planet.new(
+    1.53796971148509165e+01,
+    -2.59193146099879641e+01,
+    1.79258772950371181e-01,
+    2.68067772490389322e-03,
+    1.62824170038242295e-03,
+    -9.51592254519715870e-05,
+    5.15138902046611451e-05)
+]
+
+
+n = Integer(ARGV[0])
+
+offset_momentum(BODIES)
+
+puts "%.9f" % energy(BODIES)
+
+nbodies = BODIES.size
+dt = 0.01
+
+n.times do
+  i = 0
+  while i < nbodies
+    b = BODIES[i]
+    b.move_from_i(BODIES, nbodies, dt, i + 1)
+    i += 1
+  end
+end
+
+puts "%.9f" % energy(BODIES)

data/sources/ruby/nestedloop.ruby

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+# -*- mode: ruby -*-
+# $Id: nestedloop.ruby,v 1.1.1.1 2004-05-19 18:10:57 bfulgham Exp $
+# http://www.bagley.org/~doug/shootout/
+# from Avi Bryant
+
+n = Integer(ARGV.shift || 1)
+x = 0
+n.times do
+    n.times do
+	n.times do
+	    n.times do
+		n.times do
+		    n.times do
+			x += 1
+		    end
+		end
+	    end
+	end
+    end
+end
+puts x

data/sources/ruby/nsieve.ruby

@@ -0,0 +1,36 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+#
+# contributed by Glenn Parker, March 2005
+# modified by Evan Phoenix, Sept 2006
+
+def sieve(m)
+  flags = Flags.dup[0,m]
+  count = 0
+  pmax = m - 1
+  p = 2
+  while p <= pmax
+    unless flags[p].zero?
+      count += 1
+      mult = p
+      while mult <= pmax
+        flags[mult] = 0
+        mult += p
+      end
+    end
+    p += 1
+  end
+  count
+end
+
+n = (ARGV[0] || 2).to_i
+
+Flags = "\x1" * ( 2 ** n * 10_000)
+
+n.downto(n-2) do |exponent|
+  break if exponent < 0
+  m = (1 << exponent) * 10_000
+  # m = (2 ** exponent) * 10_000
+  count = sieve(m)
+  printf "Primes up to %8d %8d\n", m, count
+end

data/sources/ruby/nsieve.ruby-2.ruby

@@ -0,0 +1,25 @@
+# The Computer Language Shootout
+# http://shootout.alioth.debian.org/
+# contributed by Pavel Valodzka
+
+def nsieve(m)
+  is_prime = Array.new(m, true)
+  count = 0
+  2.upto(m){|i|
+    if is_prime[i]
+      (2 * i).step(m, i){|v|
+        is_prime[v] = false
+      }
+      count += 1
+    end
+  }
+  return count
+end
+
+n = (ARGV[0] || 2).to_i
+n = 2 if (n < 2)
+
+3.times {|t|
+  m = (1<<n-t)*10000
+  printf("Primes up to %8d%9d\n", m, nsieve(m))  
+}

data/sources/ruby/nsievebits.ruby-2.ruby

@@ -0,0 +1,42 @@
+#!/usr/bin/ruby
+#
+# The Great Computer Language Shootout 
+# http://shootout.alioth.debian.org/
+#
+# nsieve-bits in Ruby
+# Contributed by Glenn Parker, March 2005
+
+CharExponent = 3
+BitsPerChar = 1 << CharExponent
+LowMask = BitsPerChar - 1
+
+def sieve(m)
+  items = "\xFF" * ((m / BitsPerChar) + 1)
+  masks = ""
+  BitsPerChar.times do |b|
+    masks << (1 << b).chr
+  end
+
+  count = 0
+  pmax = m - 1
+  2.step(pmax, 1) do |p|
+    if items[p >> CharExponent][p & LowMask] == 1
+      count += 1
+      p.step(pmax, p) do |mult|
+	a = mult >> CharExponent
+	b = mult & LowMask
+	items[a] -= masks[b] if items[a][b] != 0
+      end
+    end
+  end
+  count
+end
+
+n = (ARGV[0] || 2).to_i
+n.step(n - 2, -1) do |exponent|
+  break if exponent < 0
+  m = 2 ** exponent * 10_000
+  count = sieve(m)
+  printf "Primes up to %8d %8d\n", m, count
+end
+