simulator 0.1.2

data/features/step_definitions/savings_simulation_steps.rb

@@ -0,0 +1,40 @@
+require 'simulator'
+include Simulator
+
+Given /^a savings model$/ do
+  @model = Model.new
+end
+
+Given /^variable "([_\w]+)"$/ do |var_name|
+  @model.add_variable Variable.new var_name.to_sym
+end
+
+Given /^equation "(.*?)" bound to ([\w_]+)$/ do |eqtn_str, var_name|
+  var = @model.get_variable var_name.to_sym
+  eqtn = Equation.new var do
+    eval eqtn_str
+  end
+  @model.add_equation eqtn
+end
+
+Given /^the value (-?[\d\.]+) bound to ([\w_]+)$/ do |value, name|
+  @run.set name.to_sym => value.to_f
+end
+
+Given /^a new run of the model$/ do
+  @run = Run.new @model
+end
+
+When /^I step the run for (\d+) periods$/ do |period_count|
+  period_count.to_i.times do
+    @run.step
+  end
+end
+
+Then /^the value (-?[\d\.]+) should be bound to ([\w_]+)$/ do |expected, var_name|
+  actual = @run.variable_value var_name.to_sym
+  actual.should be_within(0.001).of expected.to_f
+end
+
+
+

data/lib/simulator.rb

@@ -0,0 +1,14 @@
+require "simulator/version"
+require 'simulator/equation'
+require 'simulator/variable'
+require 'simulator/bound_variable'
+require 'simulator/variable_context'
+require 'simulator/sandbox'
+require 'simulator/model'
+require 'simulator/run'
+require 'simulator/period'
+require 'simulator/data'
+
+module Simulator
+end
+

data/lib/simulator/bound_variable.rb

@@ -0,0 +1,18 @@
+module Simulator
+  # represents a variable bound to a context
+  class BoundVariable
+    attr_accessor :value
+    attr_reader :context, :variable
+
+    def initialize(variable, context)
+      @variable = variable
+      @value = @variable.default_value
+      @context = context
+    end
+
+    def name
+      @variable.name
+    end
+  end
+end
+

data/lib/simulator/data.rb

@@ -0,0 +1,23 @@
+module Simulator
+  class Data
+    attr_accessor :periods
+    def series(*var_names)
+      data = var_names.collect do |var_name|
+        @periods.collect do |period|
+          var = period.context.get var_name
+          var.value unless var.nil?
+        end
+      end
+
+      # If we just hae one series, then just return the first
+      var_names.length == 1 ? data.first : data
+    end
+    def series_with_headers(*var_names)
+      data = series *var_names
+      table = var_names.zip data
+      table.collect do |row|
+        row.flatten
+      end
+    end
+  end
+end

data/lib/simulator/equation.rb

@@ -0,0 +1,16 @@
+module Simulator
+  class Equation
+    attr_reader :variable 
+
+    def initialize(var, &equation)
+      @equation_block = equation
+      @variable = var
+    end
+
+    # evaluate the equation in the passed context
+    def evaluate_in(context, periods = [])
+      sandbox = Sandbox.new context, periods
+      sandbox.instance_eval &@equation_block
+    end
+  end
+end

data/lib/simulator/model.rb

@@ -0,0 +1,43 @@
+module Simulator
+  #
+  class Model
+    attr_accessor :name
+    attr_reader :equations
+
+    def initialize(&block)
+      @equations = []
+      @variables = {}
+      instance_eval &block unless block.nil?
+    end
+    def var(name, default_value = nil)
+      v = get_variable(name)
+      if v.nil?
+        v = Variable.new name, default_value
+        add_variable v
+      end
+      v
+    end
+    def eqtn(var_name, default_value = nil, &block)
+      v = var(var_name, default_value)
+      e = Equation.new(v, &block)
+      add_equation e
+      e
+    end
+    def add_equation(equation)
+      @equations << equation
+    end
+    def add_variable(variable)
+      @variables[variable.name] = variable
+    end
+    def get_variable(name)
+      @variables[name]
+    end
+    def variables
+      @variables.values
+    end
+
+    def new_run
+      Run.new self
+    end
+  end
+end

data/lib/simulator/period.rb

@@ -0,0 +1,28 @@
+module Simulator
+  class Period
+    attr_reader :context
+    attr_reader :run
+    attr_reader :previous_periods
+
+    def initialize(run, previous_periods = [])
+      @run = run
+      @previous_periods = previous_periods
+      @context = @previous_periods.empty? ? VariableContext.new : previous.context.clone
+    end
+
+    # the first period
+    def first
+      @previous_periods.first
+    end
+
+    # the period before this one
+    def previous
+      @previous_periods.last
+    end
+
+    # returns a period count ago
+    def ago(count)
+      count == 0 ? self : @previous_periods[-count]
+    end
+  end
+end

data/lib/simulator/run.rb

@@ -0,0 +1,95 @@
+module Simulator
+  # A run of a model. It has its own context
+  class Run
+    attr_reader :model
+    attr_reader :periods
+
+    def initialize(model)
+      @model = model
+      @periods = [Period.new(self)]
+      current_context.add_variables *@model.variables
+    end
+
+    def evaluate
+      # evaluate the equations in the current context
+      @model.equations.each do | eqtn |
+        result = eqtn.evaluate_in current_context, @periods
+        var = eqtn.variable
+        bound_var = current_context.get(var.name)
+        bound_var.value = result
+      end
+    end
+
+    def increment_period
+      p = Period.new self, @periods.dup
+      @periods << p
+      p
+    end
+
+    def step
+      evaluate
+      increment_period
+    end
+
+    # The number of periods so far. All runs have at least 1 period.
+    def period_count
+      @periods.length
+    end
+
+    # Returns the current_context, that is the variable context of the last 
+    # period.
+    def current_context
+      @periods.last.context
+    end
+
+    def variables
+      current_context.variables
+    end
+
+    def set(var_hash)
+      current_context.set var_hash
+    end
+
+    def variable_value(var_name)
+      current_context.get(var_name).value
+    end
+
+    def summary
+      var_list = variables.sort_by(&:name).collect do |v|
+        "\t#{v.name} = #{v.value}"
+      end.join("\n")
+      model_summary = %Q{Model "#{@model.name}"}
+      period_summary = "Period #{period_count}"
+
+      "#{model_summary}\n#{period_summary}\nVariables:\n#{var_list}"
+    end
+
+    def variables_csv
+      vars = variables.sort_by(&:name)
+      var_names = vars.collect(&:name)
+      header = "'Period',#{var_names.collect{|n| "'#{n}'"}.join(',')}"
+
+      rows = []
+      @periods.each_index do |index|
+        period = @periods[index]
+
+        context = period.context
+        var_values = var_names.collect do | var_name |
+          var = context.get var_name
+          var.value
+        end.join(',')
+
+        rows << "#{index},#{var_values}"
+      end
+
+      "#{header}\n#{rows.join("\n")}"
+    end
+
+    def data
+      data = Data.new
+      data.periods = @periods
+      data
+    end
+  end
+end
+

data/lib/simulator/sandbox.rb

@@ -0,0 +1,31 @@
+module Simulator
+  class Sandbox
+    def initialize(context, periods = [])
+      @context = context
+      @periods = periods
+    end
+
+    private
+
+    def delay(var_name, var_periods)
+      throw 'First parameter must be a variable symbol' unless var_name.class == Symbol
+
+      # Get the period n steps back
+      period = @periods[-var_periods] # We might have to add 1 period back (- (var_periods+1))
+      context = period.context
+      var = context.get var_name
+      var.value unless var.nil?
+    end
+
+    def respond_to?(sym)
+      puts "Respond to: #{sym}"
+      not @context.get(sym.to_sym).nil?
+    end
+
+    def method_missing(method_name, *args, &block)
+      var = @context.get method_name.to_sym
+      return var.value unless var.nil?
+      super(method_name, *args, &block)
+    end
+  end
+end

data/lib/simulator/variable.rb

@@ -0,0 +1,11 @@
+module Simulator
+  class Variable
+    attr_reader :name, :default_value
+
+    def initialize(name, default_value = nil)
+      @name = name
+      @default_value = default_value
+    end
+  end
+end
+

data/lib/simulator/variable_context.rb

@@ -0,0 +1,66 @@
+module Simulator
+  class VariableContext
+    def initialize
+      @variables_hash = {}
+    end
+
+    def add(var_hash)
+      vars = var_hash.collect do |k, v|
+        Variable.new k
+      end
+      add_variables *vars
+      set var_hash
+    end
+
+    # add variables. doesn't check for uniqueness, does not overwrite existing
+    def add_variables(*vars)
+      # create bound variables for each variable
+      bound_vars = vars.collect do |v|
+        BoundVariable.new v, self
+      end
+
+      # add all the bound variables to the variables hash
+      keys = vars.collect(&:name)
+      append_hash = Hash[ keys.zip(bound_vars) ]
+      @variables_hash.merge!(append_hash) do |key, oldval, newval|
+        oldval # the first bound variable
+      end
+    end
+
+    # Use to set the value for a variety of variables
+    def set(var_hash)
+      var_hash.each do |variable_name, value|
+        throw :MissingVariable unless @variables_hash.has_key? variable_name
+
+        bv = @variables_hash[variable_name]
+        bv.value = value
+      end
+    end
+
+    def get(var_name)
+      @variables_hash[var_name]
+    end
+
+    def variables
+      @variables_hash.values
+    end
+
+    def unbound_variables
+      variables.collect(&:variable)
+    end
+
+    def clone
+      copy = VariableContext.new
+      copy.add_variables *unbound_variables
+
+      # create a value hash of variable names and values
+      value_hash = variables.inject({}) do |memo, v|
+        memo[v.name] = v.value
+        memo
+      end
+      copy.set value_hash
+      copy
+    end
+  end
+end
+

data/lib/simulator/version.rb

@@ -0,0 +1,3 @@
+module Simulator
+  VERSION = "0.1.2"
+end

data/simulator.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/simulator/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jamie Ly"]
+  gem.email         = ["me@jamie.ly"]
+  gem.description   = %q{Use to simulate discrete time models. See the examples directory for examples.}
+  gem.summary       = %q{Use to simulate discrete time models.}
+  gem.homepage      = "http://github.com/jamiely/simulator"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "simulator"
+  gem.require_paths = ["lib"]
+  gem.version       = Simulator::VERSION
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'cucumber'
+end

data/spec/beer_spec.rb

@@ -0,0 +1,91 @@
+require 'simulator'
+include Simulator
+
+describe "a beer distribution simulation" do
+  before :each do
+    @model = Model.new do
+      name = "Beer Distribution"
+
+      var :time_to_ship, 1
+      var :vendor_orders, 10
+      eqtn :available_goods do
+        delay :vendor_orders, time_to_ship
+      end
+
+      eqtn :ordered_from_vendors do
+        if ordered_from_vendors.nil?
+          vendor_orders
+        else
+          delta = vendor_orders - available_goods
+          ordered_from_vendors + delta
+        end
+      end
+
+      var :time_to_build_product, 1
+      eqtn :wip_completion do
+        delay :available_goods, time_to_build_product
+      end
+      eqtn :work_in_progress do
+        if work_in_progress.nil?
+          available_goods
+        else
+          delta = available_goods - wip_completion
+          work_in_progress + delta
+        end
+      end
+      eqtn :finished_goods_inventory do
+        if finished_goods_inventory.nil?
+          wip_completion
+        else
+          delta = wip_completion - shipments
+          finished_goods_inventory + delta
+        end
+      end
+
+      var :new_customer_orders, 10 # this should be an equation later
+      eqtn :unfilled_orders do
+        [0, new_customer_orders - shipments].max
+      end
+      eqtn :total_customer_orders do
+        cumulative_unfilled_orders + new_customer_orders
+      end
+      eqtn :shipments, 0 do
+        [total_customer_orders, finished_goods_inventory].min
+      end
+
+      eqtn :inventory_coverage do
+        begin
+          finished_goods_inventory/total_customer_orders 
+        rescue
+          0
+        end
+      end
+
+      var :fraction_of_unfilled_orders_that_are_cancelled, 0.25
+      eqtn :cancelled_unfilled_orders do
+        tmp = cumulative_unfilled_orders - filled_orders
+        tmp2 = tmp * fraction_of_unfilled_orders_that_are_cancelled
+        tmp2.round
+      end
+
+      eqtn :cumulative_unfilled_orders, 0 do
+        delta = unfilled_orders - filled_orders - cancelled_unfilled_orders
+        cumulative_unfilled_orders + delta
+      end
+
+      eqtn :filled_orders, 0 do 
+        [0, shipments - new_customer_orders].max
+      end
+      eqtn :lost_orders, 0 do
+        lost_orders + cancelled_unfilled_orders
+      end
+    end
+
+    @run = Run.new @model
+  end
+
+  it "can step a run" do
+    @run.period_count.should eq 1
+  end
+end
+