Higher-Order Ruby

#!/usr/local/bin/ruby -w

$cache = Hash.new

def rgb_to_cmyk(*rgb)
  return $cache[rgb] if $cache.include?(rgb)
  c, m, y     = rgb.map { |color| 255 - color }
  k           = [c, m, y].min
  $cache[rgb] = [c, m, y].map { |color| color - k } + [k]
end

unless ARGV.size == 3 && ARGV.all? { |n| n =~ /\A\d+\Z/ }
  abort "Usage:  #{File.basename($PROGRAM_NAME)} RED GREEN BLUE"
end

puts rgb_to_cmyk(*ARGV.map { |num| num.to_i }).join(", ")

#!/usr/local/bin/ruby -w

cmyk = Hash.new do |colors, rgb|
  c, m, y     = rgb.map { |color| 255 - color }
  k           = [c, m, y].min
  colors[rgb] = [c, m, y].map { |color| color - k } + [k]
end

unless ARGV.size == 3 && ARGV.all? { |n| n =~ /\A\d+\Z/ }
  abort "Usage:  #{File.basename($PROGRAM_NAME)} RED GREEN BLUE"
end

puts cmyk[ARGV.map { |num| num.to_i }].join(", ")

#!/usr/local/bin/ruby -w

#
# memoizable.rb
#
#  Created by James Edward Gray II on 2006-01-21.
#  Copyright 2006 Gray Productions. All rights reserved.
#

# 
# Have your class or module <tt>extend Memoizable</tt> to gain access to the 
# #memoize method.
# 
module Memoizable
  # 
  # This method is used to replace a computationally expensive method with an
  # equivalent method that will answer repeat calls for indentical arguments 
  # from a _cache_.  To use, make sure the current class extends Memoizable, 
  # then call by passing the _name_ of the method you wish to cache results for.
  # 
  # The _cache_ object can be any object supporting both #[] and #[]=.  The keys
  # used for the _cache_ are an Array of the arguments the method was called 
  # with and the values are just the returned results of the original method 
  # call.  The default _cache_ is a simple Hash, providing in-memory storage.
  # 
  def memoize(name, cache = Hash.new)
    original = "__unmemoized_#{name}__"

    # 
    # <tt>self.class</tt> is used for the top level, to modify Object, otherwise
    # we just modify the Class or Module directly
    # 
    ([Class, Module].include?(self.class) ? self : self.class).class_eval do
      alias_method original, name
      private      original
      define_method(name) { |*args| cache[args] ||= send(original, *args) }
    end
  end
end

class Fibonacci
  extend Memoizable

  def fib(num)
    return num if num < 2
    fib(num - 1) + fib(num - 2)
  end
  memoize :fib
end

class Fibonacci
  class << self
    extend Memoizable

    def fib(num)
      return num if num < 2
      fib(num - 1) + fib(num - 2)
    end
    memoize :fib
  end
end

extend Memoizable

def fib(num)
  return num if num < 2
  fib(num - 1) + fib(num - 2)
end
memoize :fib

#!/usr/local/bin/ruby -w

#
# weak_references.rb
#
#  Created by James Edward Gray II on 2006-01-23.
#  Copyright 2006 Gray Productions. All rights reserved.
#

require "memoizable"

# 
# This cache uses weak references, which can be garbage collected.  When the 
# cache is checked, the value will be returned if it is still around, otherwise
# +nil+ is returned.
# 
# (Code by Mauricio Fernandez.)
# 
class WeakCache
  def initialize
    set_internal_hash
  end

  def method_missing(meth, *args, &block)
    __get_hash__.send(meth, *args, &block)
  end

  private

  def __get_hash__
    old_critical    = Thread.critical
    Thread.critical = true

    @valid or set_internal_hash
    return ObjectSpace._id2ref(@hash_id)
  ensure
    Thread.critical = old_critical
  end

  def set_internal_hash
    hash     = Hash.new
    @hash_id = hash.object_id
    @valid   = true

    ObjectSpace.define_finalizer(hash, lambda { @valid = false })
    hash = nil
  end
end
$cache = WeakCache.new  # makes the example below easier to show

class Fibonacci
  extend Memoizable

  def fib(num)
    return num if num < 2
    fib(num - 1) + fib(num - 2)
  end
  memoize :fib, $cache
end

puts "This method is memoized using a weak reference cache..."
start = Time.now
puts "fib(100):  #{Fibonacci.new.fib(100)}"
puts "Run time:  #{Time.now - start} seconds"

puts
puts "We will now try to get garbage collection to reclaim the cache..."
puts "Cache size:  #{$cache.size}"
puts "Running garbage collection..."
ObjectSpace.garbage_collect
puts "Cache size:  #{$cache.size}"

puts
puts "Running the test again may not be instant, but still fast..."
start = Time.now
puts "fib(100):  #{Fibonacci.new.fib(100)}"
puts "Run time:  #{Time.now - start} seconds"