davidrichards-tegu_gears 0.0.3

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 3
+:major: 0
+:minor: 0

data/lib/examples/factorial.rb

@@ -0,0 +1,6 @@
+class Factorial
+  include TeguGears
+  def process(n)
+    n <= 1 ? 1 : n * Factorial.call(n-1)
+  end
+end

data/lib/examples/fibonacci.rb

@@ -0,0 +1,7 @@
+# The Fibonacci numbers: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, etc.
+class Fibonacci
+  include TeguGears
+  def process(n)
+    n <= 2 ? 1 : Fibonacci.call(n-1) + Fibonacci.call(n-2)
+  end
+end

data/lib/examples/regression.rb

@@ -0,0 +1,59 @@
+class SSY
+  include TeguGears
+  def process(*y)
+    y_mean = Mean.call(*y)
+    y.inject{|s,e| s + (e - y_mean)**2}
+  end
+end
+
+class SSX < SSY; end
+
+class SSXY
+  include TeguGears
+  def process(x, y)
+    raise ArgumentError, "x and y need to be the same size" unless x.size == y.size
+    x_mean = Mean.call(*x)
+    y_mean = Mean.call(*y)
+    (0...x.size).inject(0.0) {|s,i| s + (y[i] - y_mean) * (x[i] - x_mean) }
+  end
+end
+
+class Mean
+  include TeguGears
+  def process(*x)
+    x.inject{|s,e| s + e} / x.size.to_f
+  end
+end
+
+class MaximumLikelihoodSlope
+  include TeguGears
+  def process(x, y)
+    raise ArgumentError, "x and y need to be the same size" unless x.size == y.size
+    b = SSXY.call(x, y) / SSX.call(x)
+  end
+end
+
+class MaximumLikelihoodIntercept
+  include TeguGears
+  def process(x,y)
+    raise ArgumentError, "x and y need to be the same size" unless x.size == y.size
+    Mean.call(*y) - MaximumLikelihoodSlope.call(x,y) * Mean.call(*x)
+  end
+end
+
+class SSE
+  include TeguGears
+  def process(x,y)
+    raise ArgumentError, "x and y need to be the same size" unless x.size == y.size
+    (0...x.size).inject(0.0) do |s, i|
+      s + (y[i] - MaximumLikelihoodIntercept.call(x,y) - MaximumLikelihoodSlope.call(x,y) * x[i] ) ** 2
+    end
+  end
+end
+
+class RSquared
+  include TeguGears
+  def process(x,y)
+    (SSY.call(*y) - SSE.call(x,y)) / SSY.call(*y)
+  end
+end

data/lib/tegu_gears.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+gem 'activesupport'
+require 'activesupport'
+
+# Add to these if you want to add class and instance methods.
+module TeguGears
+  module InstanceMethods; end
+  module ClassMethods; end
+end
+
+$:.unshift(File.dirname(__FILE__))
+require 'tegu_gears/memoize'
+Dir.glob("#{File.dirname(__FILE__)}/tegu_gears/*.rb").each { |file| require file }
+module TeguGears
+  def self.included(base)
+    base.send(:include, Memoize)
+    base.send(:include, InstanceMethods)
+    base.send(:extend, ClassMethods)
+  end
+end
+
+# Now that I have some tools setup, require some libraries that will be
+# generally useful. This will be migrated to a configurable load process
+# at some point soon. 
+
+# Requires libraries, only if they're available.
+def safe_load(val=nil, &block)
+  begin
+    if block
+      block.call
+    else
+      require val
+    end
+  # Very important that this is Exception, and not StandardError
+  rescue Exception => e 
+    false
+  end
+end
+
+safe_load 'rubygems'
+safe_load 'mathn'
+safe_load {require bigdecimal; require 'bigdecimal/math'}
+safe_load 'set'
+safe_load 'matrix'
+safe_load 'narray'
+safe_load 'rnum'
+safe_load 'gratr'
+safe_load 'tenacious_g'
+safe_load 'rbtree'
+
+# Require the examples too, they are meant to be generally interesting or useful.
+Dir.glob("#{File.dirname(__FILE__)}/examples/*.rb").each { |file| require file }

data/lib/tegu_gears/compose.rb

@@ -0,0 +1,25 @@
+module TeguGears #:nodoc:
+  
+  module InstanceMethods
+    
+    # This allows me to compose two classes using TeguGears.
+    def compose(f)
+      lambda {|*args| f.call(self.call(*args))}
+    end
+    alias :| :compose
+  end
+end
+
+class Object
+  # Composes any number of functions.  The first argument is the input.
+  # Use Struct if the argument list needs to be more expansive. 
+  def compose(*args)
+    param = args.shift
+    args.inject {|composition, f| make_binomial_composition(composition, f)}.call(param)
+  end
+  
+  def make_binomial_composition(f, g)
+    lambda{|*args| g.call(f.call(*args))}
+  end
+  private :make_binomial_composition
+end

data/lib/tegu_gears/dynamics.rb

@@ -0,0 +1,3 @@
+$:.<< File.dirname(__FILE__)
+
+require 'dynamics/node'

data/lib/tegu_gears/dynamics/node.rb

@@ -0,0 +1,6 @@
+# I'm using explicit nodes here to carry the meaning of the dynamics.  I
+# have done it another way, where I patch in some methods to anything
+# that moves.  That's a really obtrusive way to build a system, it turns
+# out.  So, I'll mix things in explicitly and see how that goes. 
+module DynamicsNode
+end

data/lib/tegu_gears/dynamics/noodle.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'gratr'
+require 'modelling'
+
+class Value
+  include Modelling
+  attributes :value => Proc.new {0.0}
+end
+
+class Value
+  attr_accessor :value
+  def initialize(value)
+    @value = value.to_f
+  end
+end
+
+class Beta < Value; end
+class Vote < Value; end
+class Income < Value; end
+class Education < Value; end
+class PartisanIdentification < Value; end
+class NeighborhoodContext < Value; end
+
+class Operator
+  include TeguGears
+  
+  # Auto-collects the in-nodes, multiplying what should be multiplied
+  def process
+    
+    args.inject { |sum, e| sum + e }
+  end
+end
+
+
+class System
+  class << self
+    def instance
+      @@instance ||= new
+    end
+  end
+  
+  attr_reader :graph
+  def initialize
+    @graph = GRATR::Digraph.new
+  end
+  
+  def add_edge(a,b,w=nil)
+    self.graph.add_edge!(a,b,w)
+  end
+  
+  def method_missing(sym, *args, &block)
+    self.graph.send(sym, *args, &block)
+  end
+end
+
+class Object
+  def method_missing(sym, *args, &block)
+    System.instance.send(sym, *args, &block)
+  end
+end
+
+# swap(old, new)

data/lib/tegu_gears/dynamics/operator.rb

@@ -0,0 +1,2 @@
+class Operator
+end

data/lib/tegu_gears/memo_repository.rb

@@ -0,0 +1,63 @@
+module TeguGears #:nodoc:
+  
+  # Should get more sophisticated with a configuration tool at some point.
+  REPOSITORY_CLASS = Hash
+  
+  # This works like a pass through to other caching tools, or keeps things
+  # in a hash.  Each class hosting TeguGear has its own entry in this
+  # repository, as does each composition.  Other caching tools may be
+  # useful to monitor the cache size, distribute it, or reduce different
+  # kinds of caching. I use a key/value interface, because that should
+  # work well with Memcache, Tokyo Cabinet, Redis, Hash, CouchDB, and
+  # other tools. 
+  # 
+  # I refactored to a centrally-managed repository because distributed
+  # caching doesn't make sense for expensive computations.  There's
+  # probably another abstraction available that will allow distributed
+  # caching only when configured, but I'll get to that when I write a
+  # configuration harness. 
+  class MemoRepository
+    
+    class << self
+      def instance
+        @@instance ||= new(REPOSITORY_CLASS.new)
+      end
+      
+      def method_missing(sym, *args, &block)
+        instance.send(sym, *args, &block)
+      end
+    end
+
+    attr_reader :store
+    def initialize(store=Hash.new)
+      @store = store
+    end
+    
+    def method_missing(sym, *args, &block)
+      self.store.send(sym, *args, &block)
+    end
+    
+    # Expects a hash on the other end, for now.
+    def set(caller, key, value)
+      key = simplify_key(key)
+      self.store[caller] ||= REPOSITORY_CLASS.new
+      self.store[caller][key] = value
+    end
+    
+    # Because I opened things up to accept an array of params instead of a single param.
+    def simplify_key(key)
+      (key.is_a?(Array) and key.size == 1) ? key.first : key
+    end
+    protected :simplify_key
+    
+    def for(caller, key=nil)
+      self.store[caller] ||= REPOSITORY_CLASS.new
+      key ? self.store[caller][key] : self.store[caller]
+    end
+    
+    def flush_for(caller)
+      self.store[caller] = REPOSITORY_CLASS.new
+    end
+    
+  end
+end

data/lib/tegu_gears/memoize.rb

@@ -0,0 +1,51 @@
+module TeguGears #:nodoc:
+  # If I can get used to using a struct or a single input variable, I can
+  # do things this way.  Otherwise, I need to get deeper into the meta
+  # programming to work around how to call things in a signatureless
+  # environment.  Not an easy nut to crack, btw. 
+  module Memoize
+    module ClassMethods
+      def instance
+        @inst ||= new
+      end
+
+      def method_missing(sym, *args, &block)
+        instance.send(sym, *args, &block)
+      end
+    end
+
+    module InstanceMethods
+      def call(*x)
+        function(*x)
+      end
+
+      def memoize
+        @memoize = true unless defined?(@memoize)
+        @memoize 
+      end
+
+      def memoize=(val)
+        @memoize = val
+      end
+
+      def function(*x)
+        self.memoize ? memoized(*x) : process(*x)
+      end
+
+      def memoized(*x)
+        MemoRepository.for(self, x) || MemoRepository.set(self, x, process(*x))
+      end
+
+      def flush
+        MemoRepository.flush_for(self)
+      end
+
+    end
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+  end
+  
+end

data/spec/lib/examples/factorial_spec.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe Factorial do
+  it "should be able to return the factorial of a number" do
+    Factorial.call(3).should eql(6)
+    Factorial.call(6).should eql(720)
+  end
+end

data/spec/lib/examples/fibonacci_spec.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe Fibonacci do
+  it "should calculate the fibonacci, up to n" do
+    Fibonacci.call(3).should eql(2)
+    Fibonacci.call(4).should eql(3)
+    Fibonacci.call(5).should eql(5)
+  end
+end

data/spec/lib/tegu_gears/compose_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe TeguGears, "compose" do
+  before(:all) do
+    class Square
+      include TeguGears
+      def process(n)
+        n ** 2
+      end
+    end
+
+    class SquareRoot
+      include TeguGears
+      def process(n)
+        Math.sqrt(n)
+      end
+    end
+  end
+  
+  it "should compose two functions manually" do
+    square_root = SquareRoot.instance
+    square = Square.instance
+    (square_root | square).call(2).should be_close(2.0, 0.0001)
+  end
+  
+  it "should be able to compose two functions from their host classes" do
+    (SquareRoot | Square).call(2).should be_close(2.0, 0.0001)
+  end
+  
+  it "should read the composition left to right" do
+    plus_two = lambda{|x| x + 2}
+    times_two = lambda{|x| x * 2}
+    # IF this was right to left, it would be 10
+    (plus_two | times_two).call(4).should eql(12)
+    (times_two | plus_two).call(4).should eql(10)
+  end
+  
+  context "from Object" do
+    it "should have a version available for any lambda or method" do
+      compose(2, SquareRoot, Square).should be_close(2.0, 0.0001)
+    end
+  
+    it "should be able to take any number of compositions at once" do
+      cube_root = lambda{|x| x ** (1/3.0)}
+      half = lambda{|x| x / 2.0}
+      twice = lambda{|x| x * 2.0}
+      quadruple = lambda{|x| x * 4.0}
+      compose(2, quadruple, twice, half, cube_root).should eql(2.0)
+    end
+    
+    it "should read left to right" do
+      plus_two = lambda{|x| x + 2}
+      times_two = lambda{|x| x * 2}
+      # IF this was right to left, it would be 10
+      compose(4, plus_two, times_two).should eql(12)
+      compose(4, times_two, plus_two).should eql(10)
+    end
+  end
+  
+  after(:all) do
+    Object.send(:remove_const, :Square)
+    Object.send(:remove_const, :SquareRoot)
+  end
+end

data/spec/lib/tegu_gears/memo_repository_spec.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe MemoRepository do
+  it "should default to a hash" do
+    @mr = MemoRepository.new
+    @mr.store.should be_is_a(Hash)
+  end
+  
+  it "should pass unknown calls to the store" do
+    @mr = MemoRepository.new
+    @mr.store.should_receive(:blah).and_return(true)
+    @mr.blah
+  end
+  
+  it "should be able to take a different kind of repository" do
+    @mr = MemoRepository.new([])
+    @mr.store.should be_is_a(Array)
+  end
+  
+  it "should provide a quasi-singleton" do
+    MemoRepository.instance.should be_is_a(MemoRepository)
+  end
+  
+  it "should set the REPOSITORY_CLASS to a Hash" do
+    REPOSITORY_CLASS.should eql(Hash)
+  end
+  
+  it "should construct REPOSITORY_CLASS for the singleton" do
+    REPOSITORY_CLASS.should_receive(:new).and_return(Hash.new)
+    MemoRepository.instance
+  end
+  
+  it "should pass unknown class calls down to the instance" do
+    MemoRepository.instance.should_receive(:weird).and_return(true)
+    MemoRepository.weird
+  end
+  
+  context "scoped access" do
+    before(:all) do
+      class A
+        include TeguGears
+        def process(n)
+          n + 1
+        end
+      end
+    end
+  
+    it "should offer a set interface, that passes a scoped memo into the repository" do
+      MemoRepository.set(A, 1, 2)
+      MemoRepository.store.keys.should be_include(A)
+    end
+  
+    context "for" do
+      it "should offer a default empty hash" do
+        MemoRepository.instance.for(:non_existent).should be_is_a(Hash)
+        MemoRepository.instance.for(:non_existent).should be_empty
+      end
+      
+      it "should offer whatever cache is available" do
+        MemoRepository.set(A, 1, 2)
+        @a_repo = MemoRepository.for(A)
+        @a_repo.keys.should eql([1])
+        @a_repo.values.should eql([2])
+      end
+      
+      it "should take an optional second parameter, which return the specific value that has been cached." do
+        MemoRepository.set(A, 1, 3)
+        MemoRepository.for(A, 1).should eql(3)
+        MemoRepository.flush_for(A)
+      end
+    end
+    
+    it "should be able to flush a single scope" do
+      MemoRepository.for(A).should_not be_empty
+      MemoRepository.flush_for(A)
+      MemoRepository.for(A).should be_empty
+    end
+    
+    after(:all) do
+      Object.send(:remove_const, :A)
+    end
+  end
+end

data/spec/lib/tegu_gears/memoize_spec.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe Memoize do
+  before(:all) do
+    class A
+      include Memoize
+      
+      def process(x)
+        x**2
+      end
+    end
+  end
+  
+  context "class methods" do
+    it "should make instance available" do
+      A.should be_respond_to(:instance)
+    end
+    
+    it "should return an instance of the host (the class that includes Memoize)" do
+      A.instance.should be_is_a(A)
+    end
+    
+    it "should pass unknown calls to host instance" do
+      @a = A.instance
+      @a.should_receive(:blah).and_return(true)
+      A.blah
+    end
+  end
+  
+  context "instance methods" do
+    
+    before(:each) do
+      @a = A.new
+    end
+    
+    it "should map call to function" do
+      @a.should_receive(:function).and_return(true)
+      @a.call(1)
+    end
+    
+    it "should make memoize accessible" do
+      @a.memoize = false
+      @a.memoize.should eql(false)
+      @a.memoize = true
+      @a.memoize.should eql(true)
+    end
+    
+    it "should default memoize to true" do
+      @a.memoize.should eql(true)
+    end
+    
+    it "should expect process to define the class' core function.  This is the only method that a host class needs to implement." do
+      @a.should_receive(:process).and_return('found me')
+      @a.call(:anything).should eql('found me')
+    end
+    
+    it "should not refer to the cache when memoize is set to false" do
+      @a.memoize = false
+      MemoRepository.should_not_receive(:for)
+      @a.call(2)
+    end
+    
+    it "should be able to clear the cache" do
+      @a.call(2)
+      @a.flush
+      MemoRepository.for(@a).should be_empty
+    end
+    
+    it "should use the MemoRepository" do
+      MemoRepository.flush_for(A)
+      MemoRepository.for(@a)[2].should be_nil
+      @a.call(2)
+      MemoRepository.for(@a)[2].should eql(4)
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :A)
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$: << File.join(File.dirname(__FILE__), "/../lib") 
+require 'rubygems' 
+require 'spec' 
+require 'tegu_gears'
+
+Spec::Runner.configure do |config|
+  
+end
+
+include TeguGears

data/spec/tegu_gears_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), "/spec_helper")
+
+describe "TeguGears" do
+  it "should require rubygems" do
+    defined?(Gem).should eql('constant')
+  end
+  
+  it "should require the examples" do
+    defined?(Fibonacci).should eql('constant')
+  end
+  
+  it "should automatically include any sub-modules when included" do
+    class A; include TeguGears end
+    A.included_modules.should be_include(TeguGears::Memoize)
+    Object.send(:remove_const, :A)
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: davidrichards-tegu_gears
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- David Richards
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-28 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: TODO
+email: davidlamontrichards@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- lib/examples
+- lib/examples/factorial.rb
+- lib/examples/fibonacci.rb
+- lib/examples/regression.rb
+- lib/tegu_gears
+- lib/tegu_gears/compose.rb
+- lib/tegu_gears/dynamics
+- lib/tegu_gears/dynamics/node.rb
+- lib/tegu_gears/dynamics/noodle.rb
+- lib/tegu_gears/dynamics/operator.rb
+- lib/tegu_gears/dynamics.rb
+- lib/tegu_gears/memo_repository.rb
+- lib/tegu_gears/memoize.rb
+- lib/tegu_gears.rb
+- spec/lib
+- spec/lib/examples
+- spec/lib/examples/factorial_spec.rb
+- spec/lib/examples/fibonacci_spec.rb
+- spec/lib/tegu_gears
+- spec/lib/tegu_gears/compose_spec.rb
+- spec/lib/tegu_gears/memo_repository_spec.rb
+- spec/lib/tegu_gears/memoize_spec.rb
+- spec/spec_helper.rb
+- spec/tegu_gears_spec.rb
+has_rdoc: true
+homepage: http://github.com/davidrichards/tegu_gears
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: []
+