Memoize 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+== 0.1.0 / 2007-05-25
+
+* First release memoized  package.

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/memoize
+lib/memoize.rb
+test/test_memoize.rb

data/README.txt

@@ -0,0 +1,48 @@
+Memoize
+    by Rakuto Furutani <rakuto@gmail.com>
+    Blog: http://rakuto.blogspot.com/
+
+== DESCRIPTION:
+  
+Memoize is implementation Memoization for Ruby, this techinique to make functions faster.
+This memoization library support own storage to save memoized data.
+
+== FEATURES/PROBLEMS:
+  
+* Memoization - http://en.wikipedia.org/wiki/Memoization
+
+== SYNOPSIS:
+
+
+== REQUIREMENTS:
+
+None
+
+== INSTALL:
+
+  % sudo gem install memoize
+
+== LICENSE:
+
+MIT License
+
+Copyright (c) 2007 Rakuto Furutani
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/memoize.rb'
+
+Hoe.new('Memoize', Memoize::VERSION) do |p|
+  p.rubyforge_name = 'memoize'
+  p.summary = 'Make functions faster by Memoization techniques'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/memoize.rb

@@ -0,0 +1,302 @@
+# Memoize is implementation Memoization for Ruby, this techinique to make functions faster.
+#
+# == Caveats:
+# * Do not memoize a function whose behaviou depends on program state.
+# * Do not memoize a function with side effects.
+# * Do not memoize a function that returns a data structure that is modified by it's caller.
+#
+# == See: 
+# Memoization - http://en.wikipedia.org/wiki/Memoization
+#
+module Memoize
+  VERSION = '0.1.0'
+  @@stores = {}
+
+  # Memoize::Storable class is abstract class. You must implement class which memoization data is saved.
+  # This module offer two storage class.
+  #
+  # * Memoize::MemoryStore -
+  # * Memoize::PStore - Persisten cache support.
+  #
+  class Storable
+    # {{{
+    attr_accessor :store
+
+    def initialize(name)
+      raise "Memoize::Strable don't instantiage for abstract class."
+    end
+
+    def set(key, value)
+    end
+
+    def get(key)
+    end
+
+    def update(key)
+    end
+
+    def delete(key)
+    end
+
+    def delete_all
+    end
+    # }}}
+  end
+
+  # MemoryStore is class which store memoization data to memory.
+  class MemoryStore < Memoize::Storable
+    # {{{
+    attr_accessor :store
+
+    def initialize
+      @store = {}
+    end
+
+    def get(key)
+      @store[key]
+    end
+
+    def set(key, value)
+      @store[key] = value
+    end
+
+    def delete(key)
+      @store.delete(key)
+    end
+
+    def delete_all
+      @store = {}
+    end
+    # }}}
+  end
+
+  # PStore is class which store memoization data with local file system.
+  # This store class be able to use persistent cache, because this class write out 
+  # cache data on file when process is exit.
+  class PStore < Memoize::MemoryStore
+    # {{{
+    attr_accessor :store
+    PREFIX_SAVE_FILE_DIR  = "/tmp"
+    SUFFIX_SAVE_FILE_EXT  = ".cache" 
+
+    def initialize(name)
+      @name = name
+      filename = encoded_filename(@name)
+      begin
+        if File.exists?(filename)
+          File.open(filename, "rb") do |io|
+            @store = Marshal.load(io)
+          end
+        else
+          @store = {}
+        end
+      rescue
+        @store = {}
+      end
+      # Write out cache 
+      at_exit {
+        File.open("#{filename}", "wb+") do |io|
+          io.flock(File::LOCK_EX)
+          Marshal.dump(@store, io)
+          io.flock(File::LOCK_UN)
+        end
+      }
+    end
+
+    # Delete all memoized data and persisten cache fille
+    def delete_all
+      filename = encoded_filename(@name)
+      File.exists?(filename) && File.unlink(filename)
+      @store = {}
+    end
+
+    private 
+    # Get the encoded file name
+    def encoded_filename(name)
+      File.join(PREFIX_SAVE_FILE_DIR, [name].pack('m').chomp+SUFFIX_SAVE_FILE_EXT)
+    end
+    # }}}
+  end
+
+  module_function
+  # Make memoized function.
+  #
+  # Parameters:
+  # * klass - You must surely specify 'self'. This parameter used to overwrite Toplevell function and 
+  #           register as toplevel function. I need to think better the means ;)
+  # * name - an memorized function name. 
+  # * options - an specify options. <tt>:as</tt> is memorized function name, default is the same second arguments value.
+  #             <tt>:store</tt> is specify class which store memorized data.
+  #
+  # == Memoized function examples
+  #   def fib(n)
+  #     return 1 if n < 2
+  #     fib(n-1) + fib(n-2)
+  #   end
+  #
+  #   end
+  #   Memoize.register(self, 'fib')
+  #   fib(30) # => 1346269 fast
+  #   fib(30) # => 1346269 very fast
+  #
+  #   # Unmemorize
+  #   Memoize.unmemoize(self, 'fib')
+  #   fib(30) # => very slow
+  #
+  # == Memoized one Object methods  
+  #   class Math2
+  #     def self.fib(N)
+  #       return 1 if n < 2
+  #       fib(n-1) + fib(n-2)
+  #     end
+  #   end
+  #
+  #   Memoize.memorize(self, 'Math2.fib')
+  #   Math.fib(30) # => fast
+  #   Math.fib(30) # => very fast
+  #   Memoize.unmemoize(self, 'Math2.fib')
+  #
+  # == Custom storage 
+  # You can use own memoized data storage, in doing so you must implementaion following method
+  #
+  # Method/Arity:
+  # * initialize/1 - this is constructor
+  # * get/1 - an get the cache data with key
+  # * set/2 - an set the cache data with key and value
+  # * delete/1 - an delete the cache data with key
+  # * delete_all/0 - an delete all cache
+  #
+  # Following class is MemCache storage sample.
+  #
+  #   # Memoized data storage using MemCache
+  #   require 'memcache'
+  #
+  #   class MemCacheStore < Memoize::Storable
+  #     attr_accessor :cache, :keys
+  #     def initialize(name)
+  #       @keys   = []
+  #       @cache  = MemCache.new 'localhost:11211', :namespace => 'rakuto.blogspot.com'
+  #     end
+  #
+  #     def get(key)
+  #       @cache.get(key)
+  #     end
+  #
+  #     def set(key, value)
+  #       @keys << key unless @keys.include?(key)
+  #       @cache.set(key, value)
+  #     end
+  #
+  #     def delete(key)
+  #       @cache.delete(key)
+  #     end
+  #
+  #     def delete_all
+  #       @keys.each { |key| @cache.delete(key) }
+  #     end
+  #   end
+  # 
+  #   Memoize.register(self, 'fib', :store => MemCacheStore)
+  #   fib(30) # => fast
+  #   fib(30) # => fast
+  #
+  def register(klass, name, options={})
+    ns = name.split(/::|\./)
+    method, klass = ns.pop, (ns.empty? ? klass : Object.const_get(ns.join("::")))
+    store     = options[:store].nil? ? PStore.new(name) : options[:store].new(name)
+    as_method = options[:as] || method
+    Memoize._set_store(name, store)
+    (class<<klass;self;end).instance_eval do  # for Ruby1.9
+      method_name           = "#{as_method}_without_memoize"
+      memoized_method_name  = "#{as_method}_with_memoize"
+      define_method(memoized_method_name) do |*args|
+        store = Memoize._get_store(name)
+        ret = store.get(args) 
+        if ret.nil?
+          ret = send(method_name, *args)
+          store.set(args, ret)
+        end
+        ret
+      end
+      alias_method method_name, method 
+      alias_method as_method, memoized_method_name
+    end
+  end
+
+  # Specify unmemoize method.
+  # If you delete persistent cache when set delete_all true.
+  #
+  # == Example
+  #   Memoize.memoize(self, 'slow_func')
+  #   slow_func(arg)
+  #   Memoize.unmemoize(self, 'slow_func')
+  # 
+  def unmemoize(klass, name, delete_all=false)
+    (class<<klass;self;end).class_eval do 
+      undef_method("#{name}_with_memoize")
+      alias_method name, "#{name}_without_memoize"
+    end
+    delete_all && @store.delete_all
+  end
+
+  # This method is public, but you don't need call directly. 
+  def _set_store(name, store)
+    @@stores[name] = store
+  end
+
+  # This method is public, but you don't need call directly. 
+  def _get_store(name)
+    @@stores[name]
+  end
+
+  # Not implemented
+  module Expire
+  end
+end
+
+if $0 == __FILE__
+  def fib(n)
+    return 1 if n < 2
+    fib(n-1) + fib(n-2)
+  end
+
+  class Math2
+    def self.fib(n)
+      return 1 if n < 2
+      fib(n-1) + fib(n-2)
+    end
+  end
+
+  class MemCacheStore < Memoize::Storable
+    attr_accessor :cache, :keys
+    def initialize(name)
+      @keys   = []
+      @cache  = MemCache.new 'localhost:11211', :namespace => 'rakuto.blogspot.com'
+    end
+
+    def get(key)
+      @cache.get(key)
+    end
+
+    def set(key, value)
+      @keys << key unless @keys.include?(key)
+      @cache.set(key, value)
+    end
+
+    def delete(key)
+      @cache.delete(key)
+    end
+
+    def delete_all
+      @keys.each { |key| @cache.delete(key) }
+    end
+  end
+
+
+  Memoize.register(self, 'Math2.fib', :store => MemCacheStore)
+  Benchmark.bm do |b|
+    b.report("fib(30) with memoize: ") { Math2.fib(30) }
+    #Memoize.unmemoize(self, 'fib')
+    b.report("fib(30)") { Math2.fib(30) }
+  end
+end

data/test/test_memoize.rb

@@ -0,0 +1,37 @@
+$: << '../lib/'
+require 'memoize'
+require 'benchmark'
+
+def fib(n)
+  return 1 if n < 2
+  fib(n-1) + fib(n-2)
+end
+
+class Math2
+  def self.fib(n)
+    return 1 if n < 2
+    fib(n-1) + fib(n-2)
+  end
+end
+
+Benchmark.bm do |b|
+  b.report("fib(30): ") { fib(30) }
+  Memoize.register(self, 'fib')
+  b.report("fib(30) with memoize") { fib(30) }
+  b.report("fib(30) with memoize") { fib(30) }
+  Memoize.unmemoize(self, 'fib')
+end
+
+Benchmark.bm do |b|
+  Memoize.register(self, 'fib', :as => 'fastfib')
+  b.report("fastfib(30) with memoize") { fastfib(30) }
+  b.report("fastfib(30) with memoize") { fastfib(30) }
+  Memoize.unmemoize(self, 'fastfib')
+end
+
+Benchmark.bm do |b|
+  b.report("fib(30): ") { Math2.fib(30) }
+  Memoize.register(self, 'Math2.fib')
+  b.report("fib(30) with memoize") { Math2.fib(30) }
+  b.report("fib(30) with memoize") { Math2.fib(30) }
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: Memoize
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-24 00:00:00 +00:00
+summary: Make functions faster by Memoization techniques
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: "    by Rakuto Furutani <rakuto@gmail.com>"
+rubyforge_project: memoize
+description: "== FEATURES/PROBLEMS:  * Memoization - http://en.wikipedia.org/wiki/Memoization  == SYNOPSIS:  == REQUIREMENTS:  None"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/memoize
+- lib/memoize.rb
+- test/test_memoize.rb
+test_files: 
+- test/test_memoize.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- memoize
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: