simplekit 0.4.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b6161ac2dfac81db037d02c9b8c67c0c03b8c44c
+  data.tar.gz: 4fd108d466e784133715c59de4ff2f9e49b8e31d
+SHA512:
+  metadata.gz: d0f7a06954e3106acde5089fea579560a3b485d4bcc258f45473a439cf98b9f78bb6e72562f728214c2daefe29a6df50b5b9496deb60d1d93a2126ed0cbadffb
+  data.tar.gz: d8602e4a17b0b12793d1c03a789e8ee5a0fa91e6f539a0fa467a61963914decba6be8c2d0e6c5a46c2c872a7f3205ced7ee0f69a6ab04fa5f6ee98379bf3f44b

data/lib/priority_queue.rb

@@ -0,0 +1,90 @@
+# Array-based PriorityQueue implementation
+class PriorityQueue
+  def initialize
+    clear
+  end
+
+  def <<(element)
+    @elements << element
+    # bubble up the element that we just added
+    bubble_up(@elements.size - 1)
+  end
+
+  alias push <<
+
+  def peek
+    # the first element will always be the min, because of the heap constraint
+    @elements[1]
+  end
+
+  def pop
+    # remove the last element of the list
+    min = @elements[1]
+
+    # and make sure the tree is ordered again
+    bubble_down(1) unless empty?
+    min
+  end
+
+  def clear
+    @elements = [nil]
+  end
+
+  def empty?
+    @elements.length < 2
+  end
+
+  private
+
+  def bubble_up(index)
+    target = @elements[index]
+    loop do
+      parent_index = (index / 2)
+
+      # return if we reach the root or the parent is less than the child
+      if parent_index < 1 || @elements[parent_index] <= target
+        @elements[index] = target
+        return
+      end
+
+      # otherwise we exchange the child with the parent
+      @elements[index] = @elements[parent_index]
+
+      # and keep bubbling up
+      index = parent_index
+    end
+  end
+
+  def bubble_down(index)
+    target = @elements.pop
+    return if empty?
+    loop do
+      child_index = (index * 2)
+
+      # stop if we reach the bottom of the tree
+      if child_index >= @elements.size
+        @elements[index] = target
+        return
+      end
+
+      # make sure we get the smallest child
+      not_the_last_element = child_index < @elements.size - 1
+      left_element = @elements[child_index]
+      right_element = @elements[child_index + 1]
+      child_index += 1 if not_the_last_element && right_element < left_element
+
+      # there is no need to continue if the parent element is already smaller
+      # then its children
+      if target <= @elements[child_index]
+        @elements[index] = target
+        return
+      end
+
+      @elements[index] = @elements[child_index]
+
+      # repeat the process until we reach a point where the parent
+      # is larger than its children
+      index = child_index
+    end
+  end
+end

data/lib/simplekit.rb

@@ -0,0 +1,90 @@
+require_relative 'priority_queue'
+
+# The +SimpleKit+ module provides basic event scheduling capabilities.
+#
+# Including +SimpleKit+ in your simulation model gives you methods +:run+,
+# +:model_time+, +:schedule+, and +:halt+ as mixins.  You <b>MUST NOT</b>
+# provide your own implementations of methods with these names in your model.
+# All but +:run+ are delegated to the +EventScheduler+ class.
+module SimpleKit
+  # The set of module methods to be passed to the EventScheduler
+  # if not found in the model class.
+  DELEGATED_METHODS = [:model_time, :schedule, :halt].freeze
+
+  # Run your model by creating a new +EventScheduler+ and invoking its
+  # +run+ method.
+  def run
+    @my_sim = EventScheduler.new(self)
+    @my_sim.run
+  end
+
+  # If a method doesn't exist in the model class, try to delegate it
+  # to +EventScheduler+.
+  def method_missing(name, *args)
+    if DELEGATED_METHODS.include?(name)
+      @my_sim.send(name, *args)
+    else
+      super
+    end
+  end
+
+  # Class +EventScheduler+ provides the computation engine for a
+  # discrete event simulation model. It uses an array-based priority
+  # queue implementation for the pending events list.
+  #
+  # Users must create a model class which:
+  # * implements an +init+ method;
+  # * Instantiates a model and invokes the +run+ method to start execution.
+  class EventScheduler
+    attr_reader :model_time, :user_model
+
+    # Initialize the +EventScheduler+ by remembering the specified model
+    # and setting up an empty event list.
+    def initialize(the_model)
+      @user_model = the_model
+      @event_list = PriorityQueue.new
+    end
+
+    # Add an event to the pending events list.
+    #
+    # *Arguments*::
+    #   - +event+ -> the event to be scheduled.
+    #   - +delay+ -> the amount of time which should elapse before
+    #     the event executes.
+    #   - +args+ -> an optional list of arguments to pass to the event
+    #     at invocation time.
+    def schedule(event, delay, *args)
+      raise 'Model scheduled event with negative delay.' if delay < 0
+      @event_list.push EventNotice.new(event, @model_time + delay, args)
+    end
+
+    # Start execution of a model. The simulation +model_time+ is initialized
+    # to zero and the model is initialized via the mandatory +init+ method.
+    # Then loop while events are pending on the +event_list+. The event with
+    # the smallest time is popped, +model_time+ is updated to the event time,
+    # and the event method is invoked.
+    def run
+      @model_time = 0.0
+      @user_model.init
+      while (current_event = @event_list.pop)
+        @model_time = current_event.time
+        @user_model.send(current_event.event, *current_event.args)
+      end
+    end
+
+    # Clear the event list, which causes termination of the simulation.
+    # Never schedule any new events after invoking +halt+.
+    def halt
+      @event_list.clear
+    end
+  end
+
+  # This is a private helper Struct for the EventScheduler class.
+  # Users should never try to access this directly.
+  EventNotice = Struct.new(:event, :time, *:args) do
+    include Comparable
+    def <=>(other)
+      time <=> other.time
+    end
+  end
+end

data/simplekit.gemspec

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+_VERSION = "0.4.5"
+
+Gem::Specification.new do |s|
+  s.name = "simplekit"
+  s.version = _VERSION
+  s.date = "2017-12-01"
+  s.summary = "Discrete event simulation engine."
+  s.homepage = "https://gitlab.nps.edu/pjsanche/simplekit-ruby.git"
+  s.email = "pjs@alum.mit.edu"
+  s.description = "This is a minimal discrete event simulation scheduling algorithm for educational use."
+  s.author = "Paul J Sanchez"
+  s.files = %w[
+    simplekit.gemspec
+    lib/simplekit.rb
+    lib/priority_queue.rb
+  ]
+  s.required_ruby_version = '>= 1.8.1'
+  s.license = 'MIT'
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: simplekit
+version: !ruby/object:Gem::Version
+  version: 0.4.5
+platform: ruby
+authors:
+- Paul J Sanchez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-01 00:00:00.000000000 Z
+dependencies: []
+description: This is a minimal discrete event simulation scheduling algorithm for
+  educational use.
+email: pjs@alum.mit.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/priority_queue.rb
+- lib/simplekit.rb
+- simplekit.gemspec
+homepage: https://gitlab.nps.edu/pjsanche/simplekit-ruby.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Discrete event simulation engine.
+test_files: []