discrete_event 1.0.0

data/README.rdoc

@@ -0,0 +1,173 @@
+= discrete_event
+
+http://github.com/jdleesmiller/discrete_event
+
+== SYNOPSIS
+
+This gem provides some tools for discrete event simulation (DES) in ruby. The
+main one is a {DiscreteEvent::EventQueue} that stores actions (ruby blocks) to
+be executed at chosen times.
+
+The example below uses the {DiscreteEvent::Simulation} class, which is a
+subclass of {DiscreteEvent::EventQueue}, to simulate an M/M/1 queueing system.
+
+  require 'rubygems'
+  require 'discrete_event'
+
+  #
+  # A single-server queueing system with Markovian arrival and service
+  # processes.
+  #
+  # Note that the simulation runs indefinitely, and that it doesn't collect
+  # statistics; this is left to the user. See mm1_queue_demo, below, for
+  # an example of how to collect statistics and how to stop the simulation
+  # by throwing the :stop symbol.
+  #
+  class MM1Queue < DiscreteEvent::Simulation
+    Customer = Struct.new(:arrival_time, :queue_on_arrival,
+                          :service_begin, :service_end)
+
+    attr_reader :arrival_rate, :service_rate, :system, :served
+
+    def initialize arrival_rate, service_rate
+      super()
+      @arrival_rate, @service_rate = arrival_rate, service_rate
+      @system = []
+      @served = []
+    end
+
+    # Sample from Exponential distribution with given mean rate.
+    def rand_exp rate
+      -Math::log(rand)/rate
+    end
+
+    # Customer arrival process.
+    # The after method is provided by {DiscreteEvent::Simulation}.
+    # The given action (a Ruby block) will run after the random delay
+    # computed by rand_exp. When it runs, the last thing the action does is
+    # call new_customer, which creates an event for the next customer.
+    def new_customer
+      after rand_exp(arrival_rate) do
+        system << Customer.new(now, queue_length)
+        serve_customer if system.size == 1
+        new_customer
+      end
+    end
+
+    # Customer service process.
+    def serve_customer
+      system.first.service_begin = now
+      after rand_exp(service_rate) do
+        system.first.service_end = now
+        served << system.shift
+        serve_customer unless system.empty?
+      end
+    end
+
+    # Number of customers currently waiting for service (does not include
+    # the one (if any) currently being served).
+    def queue_length
+      if system.empty? then 0 else system.length - 1 end
+    end
+
+    # Called by super.run.
+    def start
+      new_customer
+    end
+  end
+
+  #
+  # Run until a fixed number of passengers has been served.
+  #
+  def mm1_queue_demo arrival_rate, service_rate, num_pax
+    # Run simulation and accumulate stats.
+    q = MM1Queue.new arrival_rate, service_rate
+    num_served = 0
+    total_queue = 0.0
+    total_wait = 0.0
+    q.run do
+      unless q.served.empty?
+        raise "confused" if q.served.size > 1
+        c = q.served.shift
+        total_queue += c.queue_on_arrival
+        total_wait  += c.service_begin - c.arrival_time
+        num_served  += 1
+      end
+      throw :stop if num_served >= num_pax
+    end
+
+    # Use standard formulas for comparison.
+    rho = arrival_rate / service_rate
+    expected_mean_wait = rho / (service_rate - arrival_rate)
+    expected_mean_queue = arrival_rate * expected_mean_wait
+
+    return total_queue / num_served, expected_mean_queue,
+           total_wait  / num_served, expected_mean_wait
+  end
+
+
+
+This and other examples are available in the <tt>test/discrete_event</tt>
+directory.
+
+In this example, the whole simulation happens in a single object; if you have
+multiple objects, you can use the {DiscreteEvent::Events} mix-in to make them
+easily share a single event queue.
+
+== INSTALLATION
+
+  gem install discrete_event
+
+== REFERENCES
+
+* {http://en.wikipedia.org/wiki/Discrete_event_simulation}
+
+You may also be interested in the Ruby bindings of the GNU Science Library, which provides a variety of pseudo-random number generators and functions for generating random variates from various distributions. It also provides useful things like histograms.
+
+* {http://www.gnu.org/software/gsl/}
+* {http://rb-gsl.rubyforge.org/}
+* The libgsl-ruby package in Debian.
+
+== HISTORY
+
+<em>1.0.0:</em>
+* split {DiscreteEvent::EventQueue} out of DiscreteEvent::Simulation for
+  easier sharing between objects
+* added {DiscreteEvent::Events} mix-in
+
+<em>0.3.0:</em>
+* reorganized for compatibility with gemma 2.0; no functional changes
+* added major, minor and patch version constants
+
+<em>0.2.0:</em>
+* added DiscreteEvent::Simulation#at_each_index (removed in 1.0.0)
+* added DiscreteEvent::Simulation#recur_after
+* added DiscreteEvent::Simulation#every
+* {DiscreteEvent::FakeRand} now supports the <tt>Kernel::rand(n)</tt> form. 
+
+<em>0.1.0:</em>
+* first release
+
+== LICENSE
+
+Copyright (c) 2010-2011 John Lees-Miller
+
+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/lib/discrete_event/event_queue.rb

@@ -0,0 +1,285 @@
+module DiscreteEvent
+  #
+  # Queue of pending events; also keeps track of the clock (the current time).
+  #
+  # There are two key terms:
+  # * action: any Ruby block
+  # * event: an action to be executed at some specified time in the future
+  # Events are usually created using the {#at} and {#after} methods.
+  # The methods {#at_each}, {#every} and {#recur_after} make some important
+  # special cases more efficient.
+  #
+  # See the {file:README} for an example.
+  #
+  class EventQueue
+    #
+    # Event queue entry for events; you do not need to use this class directly.
+    #
+    Event = Struct.new(:time, :action)
+
+    #
+    # Current time (taken from the currently executing event, if any). You can
+    # use floating point or integer time.
+    #
+    # @return [Number]
+    #
+    attr_reader :now
+
+    #
+    # Event queue.
+    #
+    # @return [PQueue]
+    #
+    attr_reader :events
+
+    def initialize now=0.0
+      @now = now
+      @events = PQueue.new {|a,b| a.time < b.time}
+      @recur_interval = nil
+    end
+
+    #
+    # Schedule +action+ (a block) to run at the given +time+; +time+ must not be
+    # in the past.
+    #
+    # @param [Number] time at which +action+ should run; must be >= {#now}
+    #
+    # @yield [] action to be run at +time+
+    #
+    # @return [nil]
+    #
+    def at time, &action
+      raise "cannot schedule event in the past" if time < now
+      @events.push(Event.new(time, action))
+      nil
+    end
+
+    #
+    # Schedule +action+ (a block) to run after the given +delay+ (with respect
+    # to {#now}).
+    #
+    # @param [Number] delay after which +action+ should run; non-negative
+    #
+    # @yield [] action to be run after +delay+
+    #
+    # @return [nil]
+    #
+    def after delay, &action
+      at(@now + delay, &action)
+    end
+
+    #
+    # Schedule +action+ (a block) to run for each element in the given list
+    # (possibly at different times).
+    # 
+    # This method may be of interest if you have a large number of events that
+    # occur at known times. You could use {#at} to add each one to the event
+    # queue at the start of the simulation, but this will make adding other
+    # events more expensive. Instead, this method adds them one at a time, so
+    # only the next event is stored in the event queue.
+    #
+    # @example
+    #   Alert = Struct.new(:when, :message)
+    #   alerts = [Alert.new(12, "ha!"), Alert.new(42, "ah!")] # and many more
+    #   at_each alerts, :when do |alert|
+    #     puts alert.message
+    #   end
+    #
+    # @param [Enumerable] elements to yield; must be in ascending order
+    #        according to +time+; note that this method keeps a reference to
+    #        this object and removes elements as they are executed, so you may
+    #        want to pass a copy if you plan to change it after this call
+    #        returns
+    #
+    # @param [Proc, Symbol, nil] time used to determine when the action will run
+    #        for a given element; if a +Proc+, the proc must return the
+    #        appropriate time; if a +Symbol+, each element must respond to
+    #        +time+; if nil, it is assumed that <tt>element.time</tt> returns
+    #        the time
+    #
+    # @yield [element]
+    #
+    # @yieldparam [Object] element from +elements+
+    #
+    # @return [nil]
+    #
+    def at_each elements, time=nil, &action
+      raise ArgumentError, 'no action given' unless block_given?
+
+      unless elements.empty?
+        element = elements.shift
+        if time.nil?
+          element_time = element.time
+        elsif time.is_a? Proc
+          element_time = time.call(element) 
+        elsif time.is_a? Symbol
+          element_time = element.send(time)
+        else 
+          raise ArgumentError, "bad time"
+        end
+
+        at element_time do
+          yield element
+          at_each elements, time, &action
+        end
+      end
+      nil
+    end
+
+    #
+    # When called from within an action block, repeats the action block after
+    # the specified +interval+ has elapsed.
+    #
+    # Calling this method from outside an action block has no effect.
+    # You may call this method at most once in an action block.
+    #
+    # @example
+    #   at 5 do
+    #     puts "now: #{now}"
+    #     recur_after 10*rand
+    #   end
+    #
+    # Note that you can achieve the same effect using {#at} and {#after} and a
+    # named method, as in
+    #   def demo
+    #     at 5 do
+    #       puts "now: #{now}"
+    #       after 10*rand do
+    #         demo
+    #       end
+    #     end
+    #   end
+    # but it is somewhat more efficient to call +recur_after+, and, if you do,
+    # the named method is not necessary.
+    #
+    # @param [Number] interval non-negative
+    #
+    # @return [nil]
+    #
+    def recur_after interval
+      raise "cannot recur twice" if @recur_interval
+      @recur_interval = interval
+      nil
+    end
+
+    # 
+    # Schedule +action+ (a block) to run periodically.
+    #
+    # This is useful for statistics collection.
+    #
+    # Note that if you specify one or more events of this kind, the simulation
+    # will never run out of events.
+    #
+    # @example
+    #   every 5 do
+    #     if now > 100
+    #       # record stats
+    #     end
+    #     throw :stop if now > 1000
+    #   end
+    #
+    # @param [Numeric] interval non-negative
+    #
+    # @param [Numeric] start block first runs at this time
+    #
+    # @return [nil]
+    #
+    def every interval, start=0, &action
+      at start do
+        yield
+        recur_after interval
+      end
+      nil
+    end
+
+    #
+    # The time of the next queued event, or +nil+ if there are no queued events.
+    #
+    # If this method is called from within an action block, it returns {#now}
+    # (that is, the current event hasn't finished yet, so it's still in some
+    # sense the next event).
+    #
+    # @return [Number, nil] 
+    #
+    def next_event_time
+      event = @events.top
+      if event
+        event.time
+      else
+        nil
+      end
+    end
+
+    #
+    # Run the action for the next event in the queue.
+    #
+    # @return [Boolean] false if there are no more events.
+    #
+    def run_next
+      event = @events.top
+      if event
+        # run the action
+        @now = event.time
+        event.action.call
+
+        # recurring events get special treatment: can avoid doing a push and a
+        # pop by reusing the Event at the top of the heap, but with a new time
+        #
+        # NB: this assumes that the top element in the heap can't change due to
+        # the event that we just ran, which is the case here, because we don't
+        # allow events to be created in the past, and because of the internals
+        # of the PQueue datastructure
+        if @recur_interval
+          event.time = @now + @recur_interval
+          @events.replace_top(event)
+          @recur_interval = nil
+        else
+          @events.pop
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # Allow for the creation of a ruby +Enumerator+ for the simulation. This
+    # yields for each event.
+    #
+    # @example TODO
+    #   eq = EventQueue.new
+    #   eq.at 13 do
+    #     puts "hi"
+    #   end
+    #   eq.at 42 do
+    #     puts "hello"
+    #   end
+    #   for t in eq.to_enum
+    #     puts t
+    #   end
+    #
+    # @yield [now] called immediately after each event runs
+    #
+    # @yieldparam [Number] now as {#now}
+    #
+    # @return [self]
+    #
+    def each
+      yield now while run_next
+      self
+    end
+
+    # 
+    # Clear any pending events in the event queue and reset {#now}.
+    #
+    # @return [self]
+    #
+    def reset now=0.0
+      @now = now
+      @events.clear
+      self
+    end
+  end
+end
+

data/lib/discrete_event/events.rb

@@ -0,0 +1,94 @@
+module DiscreteEvent
+  #
+  # Mix-in for simulations with multiple objects that have to share the same
+  # clock. See the {file:README} for an example.
+  #
+  # The implementing class must have an instance method <tt>event_queue</tt>
+  # that returns the {EventQueue} to use; this method may be private.
+  #
+  module Events
+    #
+    # See {EventQueue#at}.
+    #
+    # @param [Number] time at which +action+ should run; must be >= {#now}
+    #
+    # @yield [] action to be run at +time+
+    #
+    # @return [nil]
+    #
+    def at time, &action
+      event_queue.at(time, &action)
+    end
+
+    #
+    # See {EventQueue#after}.
+    #
+    # @param [Number] delay after which +action+ should run; non-negative
+    #
+    # @yield [] action to be run after +delay+
+    #
+    # @return [nil]
+    #
+    def after delay, &action
+      event_queue.after(delay, &action)
+    end
+
+    #
+    # See {EventQueue#at_each}.
+    #
+    # @param [Enumerable] elements to yield; must be in ascending order
+    #        according to +time+; note that this method keeps a reference to
+    #        this object and removes elements as they are executed, so you may
+    #        want to pass a copy if you plan to change it after this call
+    #        returns
+    #
+    # @param [Proc, Symbol, nil] time used to determine when the action will run
+    #        for a given element; if a +Proc+, the proc must return the
+    #        appropriate time; if a +Symbol+, each element must respond to
+    #        +time+; if nil, it is assumed that <tt>element.time</tt> returns
+    #        the time
+    #
+    # @yield [element]
+    #
+    # @yieldparam [Object] element from +elements+
+    #
+    # @return [nil]
+    #
+    def at_each elements, time=nil, &action
+      event_queue.at_each(elements, time, &action)
+    end
+
+    #
+    # See {EventQueue#recur_after}.
+    #
+    # @param [Number] interval non-negative
+    #
+    # @return [nil]
+    #
+    def recur_after interval
+      event_queue.recur_after(interval)
+    end
+
+    # 
+    # See {EventQueue#every}.
+    #
+    # @param [Numeric] interval non-negative
+    #
+    # @param [Numeric] start block first runs at this time
+    #
+    # @return [nil]
+    def every interval, start=0, &action
+      event_queue.every(interval, start, &action)
+    end
+
+    #
+    # See {EventQueue#now}.
+    #
+    # @return [Number]
+    #
+    def now
+      event_queue.now
+    end
+  end
+end
+

data/lib/discrete_event/fake_rand.rb

@@ -0,0 +1,73 @@
+module DiscreteEvent
+  #
+  # A utility for testing objects that use the built-in Ruby pseudorandom
+  # number generator (+Kernel::rand+); use it to specify a particular sequence
+  # of (non-random) numbers to be returned by +rand+.
+  #
+  # Using this utility may be better than running tests with a fixed seed,
+  # because you can specify random numbers that produce particular behavior.
+  #
+  # The sequence is specific to the object that you give to {.for}; this means
+  # that you must specify a separate fake sequence for each object in the
+  # simulation (which is usually easier than trying to specify one sequence for
+  # the whole sim, anyway).
+  #
+  # @example
+  #   class Foo
+  #     def do_stuff
+  #       # NB: FakeRand.for won't work if you write "Kernel::rand" instead of
+  #       # just "rand," here.
+  #       puts rand
+  #     end
+  #   end
+  #   foo = Foo.new
+  #   foo.do_stuff # outputs a pseudorandom number
+  #   DiscreteEvent::FakeRand.for(foo, 0.0, 0.1)
+  #   foo.do_stuff # outputs 0.0
+  #   foo.do_stuff # outputs 0.1
+  #   foo.do_stuff # raises an exception
+  #
+  module FakeRand
+    #
+    # Create a method +rand+ in +object+'s singleton class that returns the
+    # given fake "random numbers;" it raises an error if it runs out of fakes.
+    #
+    # @param [Object] object to modify
+    # @param [Array] fakes sequence of numbers to return
+    # @return [nil]
+    #
+    def self.for object, *fakes
+      undo_for(object) # in case rand is already faked
+      (class << object; self; end).instance_eval do
+        define_method :rand do |*args|
+          raise "out of fake_rand numbers" if fakes.empty?
+          r = fakes.shift
+
+          # can be either the rand() or rand(n) form
+          n = args.shift || 0
+          if n == 0
+            r
+          else
+            (r * n).to_i
+          end
+        end
+      end
+    end
+
+    #
+    # Reverse the effects of {.for}.
+    # If object has its own +rand+, it is restored; otherwise, the object
+    # goes back to using +Kernel::rand+.
+    #
+    # @param [Object] object to modify
+    # @return [nil]
+    #
+    def self.undo_for object
+      if object.methods.map(&:to_s).member?('rand')
+        (class << object; self; end).instance_eval do
+          remove_method :rand
+        end
+      end
+    end
+  end
+end

data/lib/discrete_event/simulation.rb

@@ -0,0 +1,37 @@
+module DiscreteEvent
+  #
+  # A simulation, including an {EventQueue}, the current time, and various
+  # helpers.
+  #
+  # See the {file:README} for an example.
+  #
+  class Simulation < EventQueue
+    #
+    # Called by +run+ when beginning a new simulation; you will probably want
+    # to override this.
+    #
+    # @abstract
+    #
+    def start
+    end
+
+    #
+    # Run (or continue, if there are existing events) the simulation until 
+    # +:stop+ is thrown, or there are no more events.
+    #
+    # @yield [] after each event runs 
+    # @return [nil]
+    #
+    def run &block
+      start if @events.empty?
+      catch :stop do
+        if block_given?
+          yield while run_next
+        else
+          nil while run_next
+        end
+      end
+    end
+  end
+end
+

data/lib/discrete_event/version.rb

@@ -0,0 +1,6 @@
+module DiscreteEvent
+  VERSION_MAJOR = 1
+  VERSION_MINOR = 0
+  VERSION_PATCH = 0
+  VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH].join('.')
+end

data/lib/discrete_event.rb

@@ -0,0 +1,22 @@
+require 'pqueue'
+
+require 'discrete_event/event_queue'
+require 'discrete_event/events'
+require 'discrete_event/simulation'
+require 'discrete_event/fake_rand'
+
+#
+# Root module; see {file:README}.
+#
+module DiscreteEvent
+  #
+  # Short form for creating a {Simulation} object.
+  #
+  # @return [Simulation]
+  #
+  def self.simulation *args, &block 
+    sim = DiscreteEvent::Simulation.new(*args)
+    sim.instance_eval(&block)
+    sim
+  end
+end

data/test/discrete_event/discrete_event_test.rb

@@ -0,0 +1,257 @@
+require 'discrete_event/test_helper'
+
+require 'discrete_event/ex_consumer.rb'
+require 'discrete_event/ex_mm1_queue.rb'
+
+include DiscreteEvent
+include DiscreteEvent::Example
+
+class TestDiscreteEvent < Test::Unit::TestCase
+  def assert_near expected, observed, tol=1e-6
+    assert((expected - observed).abs < tol,
+      "expected |#{expected} - #{observed}| < #{tol}")
+  end
+
+  def test_fake_rand
+    c = ConsumerSim.new 3
+
+    # Before faking.
+    c.run
+    assert_equal 3, c.consumed.size
+
+    # Fake rand.
+    FakeRand.for(c, 0.125, 0.25, 0.5)
+    c.reset.run
+    assert_equal [0.125, 0.375, 0.875], c.consumed
+
+    # Now have run out of fakes.
+    assert_raise(RuntimeError){ c.reset.run }
+
+    # See what happens if we fake twice.
+    FakeRand.for(c, 0.5, 0.25, 0.125)
+    c.reset.run
+    assert_equal [0.5, 0.75, 0.875], c.consumed
+
+    # Now have run out of fakes, again.
+    assert_raise(RuntimeError){ c.reset.run }
+
+    # Can undo and get original behavior back.
+    FakeRand.undo_for(c)
+    c.reset.run # no exception
+    assert_equal 3, c.consumed.size
+  end
+
+  def test_fake_rand_n
+    # Test that we can also fake random integers (for Kernel::rand(n)).
+    o = Object.new
+    class <<o
+      def test
+        rand(11)
+      end
+    end
+
+    FakeRand.for(o, 0.0, 0.1, 0.5, 0.99)
+    assert_equal 0, o.test
+    assert_equal 1, o.test
+    assert_equal 5, o.test
+    assert_equal 10, o.test
+
+    # Now have run out of fakes.
+    assert_raise(RuntimeError){ o.test }
+  end
+  
+  def test_mm1_queue_not_busy
+    # Service begins immediately when queue is not busy.
+    q = MM1Queue.new 0.5, 1.0
+    fakes = [1, 1, 1, 1, 1].map {|x| 1/Math::E**x}
+    FakeRand.for(q, *fakes)
+    q.run do
+      throw :stop if q.served.size >= 2
+    end
+    assert_near 2.0, q.served[0].arrival_time
+    assert_near 2.0, q.served[0].service_begin
+    assert_near 3.0, q.served[0].service_end
+    assert_near 4.0, q.served[1].arrival_time
+    assert_near 4.0, q.served[1].service_begin
+    assert_near 5.0, q.served[1].service_end
+  end
+  
+  def test_mm1_queue_busy
+    # Service begins after previous customer when queue is busy.
+    q = MM1Queue.new 0.5, 1.0
+    fakes = [0.1, 0.1, # arrival, service for first customer
+      0.01, 0.01,      # arrival times for second two customers
+      1,               # arrival for forth customer
+      0.1, 0.1,        # service times for second two customers
+      1].map {|x| 1/Math::E**x}
+    FakeRand.for(q, *fakes)
+    q.run do
+      throw :stop if q.served.size >= 3
+    end
+    assert_near 0.2,  q.served[0].arrival_time
+    assert_near 0.2,  q.served[0].service_begin
+    assert_near 0.3,  q.served[0].service_end
+    assert_near 0.22, q.served[1].arrival_time
+    assert_near 0.3,  q.served[1].service_begin
+    assert_near 0.4,  q.served[1].service_end
+    assert_near 0.24, q.served[2].arrival_time
+    assert_near 0.4,  q.served[2].service_begin
+    assert_near 0.5,  q.served[2].service_end
+  end
+
+  def test_recur_after
+    output = []
+    DiscreteEvent.simulation {
+      at 0 do
+        output << now
+        recur_after 5 if now < 20
+      end
+
+      run
+    }
+    assert_equal [0, 5, 10, 15, 20], output
+  end
+
+  def test_recur_after_with_after_0
+    # Putting a new event in the queue and then calling recur_after should not
+    # displace the root element, even if you call after(0), which is just an
+    # edge case anyway.
+    output = []
+    DiscreteEvent.simulation {
+      at 0 do
+        output << now
+        after 0 do
+          output << 42
+        end
+        after 1 do
+          output << 13
+        end
+        recur_after 5 if now < 10
+      end
+
+      run
+    }
+    assert_equal [0, 42, 13, 5, 42, 13, 10, 42, 13], output
+  end
+
+  def test_every
+    output = []
+    DiscreteEvent.simulation {
+      every 3 do
+        output << now
+        throw :stop if now > 10
+      end
+      run
+    }
+    assert_equal [0,3,6,9,12], output
+  end
+
+  Alert = Struct.new(:when, :message)
+
+  def test_at_each_with_symbol
+    output = []
+    DiscreteEvent.simulation {
+      alerts = [Alert.new(12, "ha!"), Alert.new(42, "ah!")] # and many more
+      at_each alerts, :when do |alert|
+        output << now << alert.message
+      end
+      run
+    }
+    assert_equal [12, 'ha!', 42, 'ah!'], output
+  end
+
+  def test_at_each_with_proc
+    output = []
+    DiscreteEvent.simulation {
+      alerts = [Alert.new(12, "ha!"), Alert.new(42, "ah!")] # and many more
+      at_each(alerts, proc{|alert| alert.when}) do |alert|
+        output << now << alert.message
+      end
+      run
+    }
+    assert_equal [12, 'ha!', 42, 'ah!'], output
+  end
+
+  Alert2 = Struct.new(:time, :message)
+  def test_at_each_with_default
+    output = []
+    DiscreteEvent.simulation {
+      alerts = [Alert2.new(12, "ha!"), Alert2.new(42, "ah!")] # and many more
+      at_each alerts do |alert|
+        output << now << alert.message
+      end
+      run
+    }
+    assert_equal [12, 'ha!', 42, 'ah!'], output
+  end
+
+  def test_next_event_time
+    output= []
+    s = DiscreteEvent.simulation {
+      at 0 do
+        output << next_event_time
+      end
+
+      at 5 do
+        output << next_event_time
+      end
+    }
+    assert_equal 0, s.next_event_time
+    assert s.run_next
+    assert_equal 5, s.next_event_time
+    assert s.run_next
+    assert_nil s.next_event_time
+
+    # as currently implemented, the "next" event includes the current event
+    assert_equal [0, 5], output
+  end
+
+  def test_enumerator
+    output = []
+    output_times = []
+    eq = EventQueue.new
+    eq.at 13 do
+      output << 'hi'
+    end
+    eq.at 42 do
+      output << 'bye'
+    end
+    for t in eq.to_enum
+      output_times << t
+    end
+    assert_equal %w(hi bye), output
+    assert_equal [13, 42], output_times
+  end
+  
+  def test_mm1_queue_demo
+    # Just run the demo... 1000 isn't enough to get a reliable average.
+    obs_q, exp_q, obs_w, exp_w= mm1_queue_demo(0.25, 0.5, 1000)
+    assert_near exp_q, 0.5   # mean queue = rho^2 / (1 - rho)
+    assert_near exp_w, 2.0   # mean wait  = rho / (mu - lambda)
+  end
+
+  def test_producer_consumer
+    event_queue = EventQueue.new(0)
+    consumer = Consumer.new(event_queue)
+    producer = Producer.new(event_queue, %w(a b c d), consumer)
+
+    FakeRand.for(consumer, 2, 2, 2, 2)
+    FakeRand.for(producer, 1, 1, 1, 1)
+
+    producer.produce
+    output = []
+    event_queue.each do |now|
+      output << [now, consumer.consumed.dup]
+    end
+    assert_equal [
+      [1, []],                # first object produced
+      [2, []],                # second object produced
+      [3, ["a"]],             # third object produced / first consumed
+      [3, ["a"]],
+      [4, ["a", "b"]],        # fourth object produced / second consumed
+      [4, ["a", "b"]],
+      [5, ["a", "b", "c"]],   # third and fourth objects consumed
+      [6, ["a", "b", "c", "d"]]], output
+  end
+end
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: discrete_event
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- John Lees-Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pqueue
+  requirement: &80923720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *80923720
+- !ruby/object:Gem::Dependency
+  name: gemma
+  requirement: &80923460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *80923460
+description: Some simple primitives for event-based discrete event simulation.
+email:
+- jdleesmiller@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/discrete_event.rb
+- lib/discrete_event/events.rb
+- lib/discrete_event/version.rb
+- lib/discrete_event/event_queue.rb
+- lib/discrete_event/simulation.rb
+- lib/discrete_event/fake_rand.rb
+- README.rdoc
+- test/discrete_event/discrete_event_test.rb
+homepage: http://github.com/jdleesmiller/discrete_event
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+- --title
+- discrete_event-1.0.0 Documentation
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -360047181
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -360047181
+requirements: []
+rubyforge_project: discrete_event
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Event-based discrete event simulation.
+test_files:
+- test/discrete_event/discrete_event_test.rb
+has_rdoc: