micro_agent 0.1.6

data/README.md

@@ -0,0 +1,79 @@
+# Micro Agent
+by VisFleet
+
+http://www.vworkapp.com
+
+## Overview:
+  
+A simple simulator. This simulates changes to a collection of agents over a period
+of time.
+
+Setup the world. Each world is populated with a number of agents. Each agent has a collection
+of properties that change over time. Properties change based on the rules you provide. Properties
+can also depend on each other (as long as you don't create a cycle!).
+   
+    update = lambda { |agent| self.update(agent) }
+    @world = Micro::World.new(1, 1, 1.0) do |i|
+      Micro::MarkovAgent.new(
+        :speed => Agent::Parameter.new do |p|
+          p.start_value = (0..100).to_a.rand
+          p.probability = 0.3
+          p.max = 100
+          p.min = 0
+          p.change_func = lambda { |value| (value + (-10..10).to_a.rand) }
+        end,
+   
+        :distance => Agent::Parameter.new do |p|
+          p.start_value = 0
+          p.depends_on :speed
+          p.change_func = lambda do |distance, speed| 
+            distance + (speed / 1.hour)
+          end
+        end
+      )
+    end
+
+Set the world in motion.  
+
+    @world.start
+
+Get a callback on each change
+
+    def change
+      @world.agents.each do |agent|
+        pp agent
+      end
+    end
+
+## Install:
+
+  sudo gem install visfleet-micro_agent
+
+### Dependancies
+
+- eventmachine (http://rubyeventmachine.com/)
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+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/examples/drivers.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require "micro_agent"
+require "active_support"
+require "pp"
+
+class Drivers
+      
+  def initialize
+    setup_world
+    @inner_kml = ""
+  end
+  
+  def setup_world
+    update = lambda { |agent| self.populate_inner_kml(agent) }
+    @world = Micro::World.new(nil, 1, 1.0, update) do |i|
+      Micro::MarkovAgent.new(
+        :name => Micro::Parameter.new do |p|
+          p.start_value = "sim_#{i.to_s}"
+        end,
+
+        :heading => Micro::Parameter.new do |p|
+          p.start_value = (0..359).to_a.rand
+          p.probability = 0.1
+          p.change_func = lambda { |value| (value + (0..120).to_a.rand) % 360 }
+        end,
+            
+        :ignition => Micro::Parameter.new do |p|
+          p.start_value = true
+          p.probability = 0.001
+          p.change_func = lambda { |value| !value}
+        end,
+      
+        :speed => Micro::Parameter.new do |p|
+          p.start_value = (1..130).to_a.rand
+          p.depends_on  = :ignition
+          p.probability = 0.2
+          p.change_func = lambda { |value, ignition| ignition ? value + (-30..30).to_a.rand : 0 }
+          p.max = 135
+          p.min = 0
+        end,
+
+        :seconds_delta => Micro::Parameter.new do |p|
+          p.start_value = 0
+          p.change_func = lambda { |value| (1..5).to_a.rand }
+        end,
+      
+        :distance_delta => Micro::Parameter.new do |p|
+          p.start_value = 0
+          p.depends_on  = :speed, :seconds_delta
+          p.change_func = lambda do |distance_delta, speed, seconds_delta|
+            # assume speed in kmph
+            distance_delta = (speed.to_f / 1.hour) * seconds_delta
+          end
+        end,
+      
+        :y => Micro::Parameter.new do |p|
+          p.start_value = -39.0
+          p.depends_on  = :heading, :distance_delta
+          p.change_func = lambda do |y, heading, distance_delta|
+            # assume heading in degress
+            y_km = Math.cos(heading / (180/Math::PI)) * distance_delta
+            # assume 111 km per 1 degree
+            y + (y_km / 111.0)
+          end
+        end,
+      
+        :x => Micro::Parameter.new do |p|
+          p.start_value = 176.0
+          p.depends_on  = :heading, :distance_delta, :y
+          p.change_func = lambda do |x, heading, distance_delta, y|
+            x_km = Math.sin(heading / (180/Math::PI)) * distance_delta
+            # assume spheriod earth
+            x + x_km / (Math.cos(y / (180/Math::PI)) * 111.0)
+          end
+        end
+      ) 
+    end
+  end
+
+  def step(number)
+    number.times { @world.step_agents }
+  end
+
+  def populate_inner_kml(agent)
+    @inner_kml << <<-EOS
+    <Placemark>
+      <name>#{agent[:name]}</name>
+      <Point>
+        <coordinates>#{agent[:x]}, #{agent[:y]}</coordinates>
+      </Point>
+    </Placemark>
+EOS
+  end
+  
+  def to_kml
+    <<-EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2">
+  <Document>
+    #{@inner_kml}
+  </Document>
+</kml>
+EOS
+  end
+  
+end
+
+d = Drivers.new
+d.step(100)
+puts d.to_kml
+

data/lib/micro_agent.rb

@@ -0,0 +1,168 @@
+require "rubygems"
+require 'eventmachine'
+
+module Micro
+
+  # The world populates  
+  # 
+  class World
+    attr_accessor :agents, :step_proc, :begin_proc, :end_proc
+  
+    def initialize(cycle_delay_seconds, number_of_agents, percent_per_cycle = 1.0, step_proc = nil, begin_proc = nil, end_proc = nil, &block)
+      @cycle_delay_seconds = cycle_delay_seconds
+      @step_proc = step_proc
+      @begin_proc = begin_proc
+      @end_proc = end_proc
+      @number_of_agents = number_of_agents
+      @create_agent_proc = block
+      @percent_per_cycle = percent_per_cycle
+      create_agents
+    end
+  
+    def create_agents
+      @agents = []
+      @number_of_agents.times do |i|
+        @agents << @create_agent_proc.call(i)
+      end
+    end
+  
+    def start
+      EM.run do
+        EventMachine::add_periodic_timer( @cycle_delay_seconds ) { step_agents }
+      end
+    end
+
+    def stop
+      EM.stop
+    end
+  
+    def step_agents
+      @begin_proc.call unless @begin_proc.nil?
+      @agents.each do |agent|
+        next unless rand <= @percent_per_cycle
+        agent.step
+        @step_proc.call(agent) unless @step_proc.nil?
+      end
+      @end_proc.call unless @end_proc.nil?
+    end
+  
+  end
+
+  # An agent is a autonomous entity that interacts with the Micro::World. Each agent has a collection 
+  # of properties that are updated over time (i.e. with each call to #step_agents in the #World).
+  # 
+  # Dependancy relationships can be setup between an agent's parameters. So that properties:
+  #   a.depends_on b.depends_on c
+  #   d.depends_on b.depends_on c
+  #   b.depends_on c
+  # This is useful where one parameter is required for calculation of another. For example, calculating a 
+  # _speed_ parameter might require you to know the values of the _distance_ and _time_ parameters. #step_agents 
+  # calculates dependancies in the correct order, making that a parameter's dependants are calculated first . 
+  # Note however that cyclic depends_on relationships aren't supported.
+  # 
+  # The runtime complexity of processing dependacies is still O(n) (where n is the number of parameters) even with
+  # complex dependency trees thanks to the niftyness of dynamic programming algorithms.
+  # 
+  class MarkovAgent
+    attr_accessor :parameters
+  
+    def initialize(parameters)
+      @parameters = parameters
+      @already_done = Hash.new
+    end
+
+    # Updates the parameter value using the parameter's change function. Each parameter is updated with
+    # probability equal to its probability value.
+    # 
+    def step(number = 1)
+      number.times do
+        @already_done.clear
+        @parameters.each_value do |parameter|
+          process(parameter)
+        end
+      end
+    end
+  
+    def [](parameter_name)
+      @parameters[parameter_name].value
+    end
+    
+    def values
+      value_hash = {}
+      @parameters.each_pair { |key, parameter| value_hash[key.to_s] = parameter.value }
+      value_hash
+    end
+
+  private
+
+    def process(parameter)
+      return parameter.value if @already_done[parameter] || parameter.change_func.nil?
+
+      values = [parameter.value]
+      parameter.depends_on.each do |p_name|
+        raise Exception.new("Can't 'depend_on' parameter #{p_name}. It doesn't exist") unless @parameters.has_key?(p_name)
+        values << process(@parameters[p_name])
+      end
+
+      if rand() <= parameter.probability
+        parameter.value = parameter.change_func.call(*values)
+        parameter.value = limit_between(parameter.value, parameter.min, parameter.max)
+      end
+      @already_done[parameter] = true
+      parameter.value
+    end
+    
+    def limit_between(value, min, max)
+      raise Exception.new("Max can't be less than Min") if min && max && (max < min)
+      value = [value, min].max if min
+      value = [value, max].min if max
+      value
+    end
+    
+  end
+  
+  # Represents an individual parameter of an agent. Parameters are updated with each call to #step_world.
+  # See the attributes below for a description of the properties that are possible on each parameter. 
+  # 
+  class Parameter
+    # The probility that this parameter is updated. Should be between 0.0 and 1.0.
+    attr_accessor :probability
+    
+    # The starting value of this parameter
+    attr_accessor :start_value
+    
+    # Takes a passed in block. The block is used to update this parameter's value. The block is passed the current
+    # value of this parameter and then the value of any dependant parameter's values (in the order they are specified
+    # in the depends_on property). This looks like:
+    #   
+    #   :speed => Micro::Parameter.new do |p|
+    #     p.start_value = 0
+    #     p.depends_on  = :distance, :time
+    #     p.change_func = lambda { |value, distance, time| distance / time }
+    #   end
+    # 
+    attr_accessor :change_func
+
+    # Specifies which parameter's this parameter is dependent on for it's calculations. See #change_func 
+    attr_accessor :depends_on
+
+    # Specifies an upper and lower bound on this parameter's value.  
+    attr_accessor :max, :min 
+    
+    attr_accessor :value 
+
+    def initialize
+      @depends_on = []
+      @probability = 1.0
+      yield self
+      @value = @start_value
+    end
+    
+    def depends_on=(p_names)
+      p_names = [p_names] unless p_names.instance_of? Array
+      @depends_on = p_names
+    end
+    
+  end
+    
+end

data/spec/micro_agent_spec.rb

@@ -0,0 +1,94 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'micro_agent'
+require 'active_support'
+
+describe Micro::World, "with a single agent" do
+  
+  before(:each) do
+    @world = Micro::World.new(1, 1) do |i|
+      Micro::MarkovAgent.new(
+        :speed => Micro::Parameter.new do |p|
+          p.start_value = (0..100).to_a.rand
+          p.probability = 0.3
+          p.max = 100
+          p.min = 0
+          p.change_func = lambda { |value| (value + (-10..10).to_a.rand) }
+        end,
+        :distance => Micro::Parameter.new do |p|
+          p.start_value = 0
+          p.depends_on = :speed
+          p.change_func = lambda do |distance, speed|
+            distance + (speed / 1.hour)
+          end
+        end,
+        :name => Micro::Parameter.new do |p|
+          p.start_value = "name"
+        end
+      )
+    end
+  end
+
+  it "should use the start_value if no change function is given" do
+    @world.step_proc = lambda do |agent| 
+      agent[:name].should == "name"
+    end
+
+    @world.step_agents
+    @world.step_agents
+    @world.step_agents
+  end
+
+  it "should stop when asked to" do
+    @world.step_proc  = lambda { |agent|  @world.stop }
+    @world.start
+  end 
+
+  it "should update it's parameters" 
+
+  it "should handle dependant parameters"
+
+  it "should call its callbacks" do
+    obj = mock("obj")
+    @world.begin_proc = lambda { obj.start }
+    @world.step_proc  = lambda { |agent| obj.during }
+    @world.end_proc   = lambda { obj.end }
+
+    obj.should_receive(:start).once
+    obj.should_receive(:during).once
+    obj.should_receive(:end).once
+    @world.step_agents
+  end
+  
+end
+
+describe Micro::World, "with many agents" do
+  
+  before(:each) do
+    @world = Micro::World.new(1, 10) do |i|
+      Micro::MarkovAgent.new(
+        :speed => Micro::Parameter.new do |p|
+          p.start_value = (0..100).to_a.rand
+          p.probability = 0.3
+          p.max = 100
+          p.min = 0
+          p.change_func = lambda { |value| (value + (-10..10).to_a.rand) }
+        end
+      )
+    end
+  end
+
+  it "should call its callback for each agent update" do
+    obj = mock("obj")
+    @world.begin_proc = lambda { obj.start }
+    @world.step_proc = lambda { |agent| obj.callback }
+    @world.end_proc   = lambda { obj.end }
+
+    obj.should_receive(:start).once
+    obj.should_receive(:callback).exactly(10)
+    obj.should_receive(:end).once
+    @world.step_agents
+  end
+  
+  it "should update the passed in percentage of the population each step" 
+  
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: micro_agent
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 6
+  version: 0.1.6
+platform: ruby
+authors: 
+- VisFleet
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-01 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: A simple simulator
+email: aisha.fenton@visfleet.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- examples/drivers.rb
+- lib/micro_agent.rb
+- README.md
+- spec/micro_agent_spec.rb
+has_rdoc: true
+homepage: http://www.vworkapp.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A simple simulator. This gem simulates changes to a collection of agents over a period of time.
+test_files: []
+