eventsims 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c14a98f8416741099ed89150135a0fcb2875cb1a
+  data.tar.gz: edb09fc49abceb6650406dbb0cbf1c23d02bbbf8
+SHA512:
+  metadata.gz: 5b944852af53fccc3b5b1d70ee041a2dce356b9d63f25c1dc730e277e7e5480b3f0a31a10f03eda1bf3239e4e5631d749265aed1b995e371670a20df170b4616
+  data.tar.gz: 1c2ef1840388301c1795bc43eab208c40713ae8398e12bee73cc600a77d418006b2933e7554812a83fa8ab7f9c4c9871be02cc314b1ae00c5868515f8f0f730d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in eventsims.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,70 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 TODO: Write your name
+
+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/README.md

@@ -0,0 +1,191 @@
+# Eventsims
+
+## Description
+
+Eventsims contains various useful tools to makes discrete event easy to simulate.
+
+
+# MODULE NAME --> Eventsims
+
+
+## Module Classes
+
+
+### Calculate 
+
+**Calculate** takes two list Arrays (outcome, cummulative probability) as arguments and an optional integer value `(steps)` for simplifying and calculating several data.
+
+#### Methods
+
+* prob() ----> To calculate the probability based on the given outcome list(second argument of the **Calculate** instance).
+* discreteemp() ----> To generate a random outcome depending on its probability of occurrence.
+* expectval() ----> To generate an expectation value i.e. the mean of the outcome depending on its probability
+* estmean() ----> Same as expectval() because they always give the same output.
+* estvar() ----> To calculate the estimated variance of the list data
+* eststddev ----> To calculate the estimated standard deviation of the list data
+
+#### Usage Example
+
+```
+require "Eventsims"
+
+sample = Eventsims::Calculate.new([-1, 0, 3, 4], [0.1, 0.4, 0.7, 1], 10)
+
+puts "probability: #{sample.prob()}"
+puts "Arrival time: #{sample.discreteemp()}"
+puts "Estimated standard deviation: #{sample.eststddev()}"
+puts "Estimated mean: #{sample.estmean()}"
+```
+#### Result
+```
+probability: [0.1, 0.3, 0.3, 0.3]
+Arrival time: [-1, 3, 0, 4, 0, -1, 3, 0, 0, 3]
+Estimated standard deviation: 6.0
+Estimated mean: 20.0
+```
+
+### Generate
+
+**Generate** that takes integer numbers as arguments *(from no argument to 5 arguments)* with optional arguments being "r" or "s". r for reverse sorted and s for ascending order sort. it's methods and uses are shown below.
+
+* outcome() —-> generate outcomes based on the inputs supplied as arguments.
+* unique() —-> generate unique outcomes based on the inputs supplied as arguments. You can think of it as a set of the outcome() method result.
+* occur() —-> generate the number of times a unique item is found.
+* getprob() —-> generate the probability of the outcome with respect to the unique outcome.
+* getcum() —-> generate the cummulative probability of occurrence with respect to the unique outcome.
+
+#### Usage example
+```
+require "Eventsims"
+
+sample = Eventsims::Generate.new(2, 5, 7, "s")
+
+puts ("Outcome: #{sample.outcome()}")
+puts ("Unique Outcome: {sample.unique()}")
+puts ("Occurrence: #{sample.occur()}")
+puts ("Probability: #sample.getprob()}")
+puts ("Cummulative Probability: #{sample.getcum()}")
+
+```
+
+#### Result
+
+```
+Outcome: [2, 3, 3, 4, 4, 5, 5]
+Unique Outcome: [2, 3, 4, 5]
+Occurrence: [1, 2, 2, 2]
+Probability: [0.1429, 0.2857, 0.2857, 0.2857]
+Cummulative Probability: [0.1429, 0.4286, 0.7143, 1.0]
+```
+### Randomsim and Simulate
+
+contains classes for generating and estimating events that happens in a workplace scenario. Simulating events using methods some methods covered below
+
+
+#### What they do
+* Randomsim which generates random values to populate the inter-arrival and service time ad then calculates the rest of the values (accepts 0 - 3 arguments)
+
+* Simulate, a more flexible class that allows you to input your own inter-arrival time and service time as a list Array (takes 1-2 arguments [inter-arrival, service] time). If only one list Array is passed to the argument. it becomes the inter-arrival time and a random list between 1 and 10 will be generated for service time
+
+
+#### Methods
+
+* intarrival() —-> Displays the inter-arrival time in a list.
+* arrival() —-> Displays the arrival time in a list.
+* service() —-> Displays the service time in a list.
+* servbegin() —-> Display the time service begins in a list.
+* servend() —-> Display the time service ends in a list.
+* queuewait() —-> Display the time the customer spent waiting in a list.
+* custspend() —-> Display the time the customer spent in the system i.e. total time of service.
+* idle() —> Display the idle time of the server (cashier).
+
+
+
+#### Usage Example
+```
+require "Eventsims"
+
+sample = Eventsims::Simulate.new([0, 1, 5, 3, 5, 5, 3, 5, 5])	#can take two arguments.
+			# or
+sample = Eventsims::Randomsim.new(5,8,9)
+puts "Inter-Arrival time: #{sample.intarrival()}"
+puts "Arrival time: #{sample.arrival()}"
+puts "Idle time: #{sample.idle()}"
+```
+
+#### Result
+```
+Inter-Arrival time: [0, 1, 5, 3, 5, 5, 3, 5, 5]
+Arrival time: [0, 1, 6, 9, 14, 19, 22, 27, 32]
+Idle time: [0, 0, 2, 0, 0, 0, 0, 0, 0]
+```
+
+## Module methods
+###trimval
+
+**trimval** that takes in one argument, (numbers or lists and strips it of leading zeros and round up to 4 decimal places 
+
+## trimlist
+
+**trimlist** that takes in as many arguments as possibe and does the same thing **trimval** does but very useful if there is a nested list in the list of arguments.
+
+`
+They both help to display lists and numbers in a better and easier way to read rather than have values with many leading decimal numbers in a list keeping it concise. `
+
+#### Usage example
+```
+require "Eventsims"
+
+sample = Eventsims.trimval([3.6789876])
+puts "new value: #{sample}"
+
+
+sample = Eventsims.trimlist([3.6789876], "dog", [2.76542, "rat", [4]])
+puts "new list: #{sample}"
+```
+	
+#### Result
+```
+new val: [[3.679]]
+new list: [[3.679], "dog", [2.7654, "rat", [4]]
+```
+
+## Requirements
+
+
+* Any version of Ruby
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'eventsims'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eventsims
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tushortz/eventsims.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.libs << "test" # here is the test_helper
+  t.pattern = "test/**/*_test.rb"
+end
+
+task default: :test
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "eventsims"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/eventsims.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eventsims/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "eventsims"
+  spec.version       = Eventsims::VERSION
+  spec.authors       = ["Taiwo Kareem"]
+  spec.email         = ["taiwo.kareem36@gmail.com"]
+
+  spec.summary       = %q{Eventsims uses various useful tools in simulating discrete system events based on outcome and probabilities}
+  spec.description   = %q{Eventsims is a Ruby package for simulating discrete event. It has  four classes (Calculate, Generate, Randomsim and Simulate) and two methods(trimval and trimlist) for making this possible. }
+  spec.homepage      = "http://github.com/tushortz/eventsims"
+  spec.license       = "MIT"
+
+  # # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  # spec.add_development_dependency "rspec"
+  # spec.add_development_dependency "guard"
+  # spec.add_development_dependency "guard-rspec"
+  # spec.add_development_dependency "coveralls"
+end

data/lib/eventsims.rb

@@ -0,0 +1,10 @@
+require "eventsims/version"
+require "eventsims/discrete"
+require "eventsims/randgen"
+require "eventsims/simevent"
+
+
+module Eventsims
+  # Your code goes here...
+end
+

data/lib/eventsims/discrete.rb

@@ -0,0 +1,207 @@
+module Eventsims
+#module Discrete
+
+#Removes leading zeros after decimal and/or approximate to 4dp
+def self.trimval(thelist)
+	''' Takes in number list or float and removes leading zeros '''
+	#Checks if passed argument is a list
+	if thelist.is_a?(Array)
+		temp = []
+		# Loops through each list and convert to 4dp if needed
+		thelist.each{|i| temp.push i.is_a?(Float)? i.round(4) : i}	
+		thelist = temp
+		return thelist
+
+	elsif thelist.is_a?(Float)
+		return thelist.round(4)
+
+	else
+		return thelist
+	end
+
+end
+
+def self.trimlist(*args)
+	''' Takes in number list or float and removes leading zeros '''
+	store = []
+	values = []
+	args.each{|mylist| 
+		a = []
+		mylist.each{|x| 
+			if x.is_a?(Float)
+				a.push(x.round(4)) 
+
+			elsif x.is_a?(Array)
+				inner = []
+				x.each{|y| inner.push y.is_a?(Float)? y.round(4) : y}
+				a.push(inner)
+
+			else a.push(x)
+
+			end
+		}
+		values.push(a)
+		
+	}
+	store.push(values)
+	return store[0]
+
+end
+
+
+class Calculate
+	def initialize(*args)
+		''' Initialising the instances '''
+		#Checking for valid arguments and value assignment
+		@args = args
+
+		if args.length == 3
+			@steps = args[2]
+		
+		elsif args.length == 2
+			@steps = 1
+
+ 		else
+ 			raise "Invalid arguments: must be 2 or 3 -->  Outcome , Cummulative probability, optional: steps"
+ 		end
+
+		@outcome, @cum_prob, @probability = args[0], args[1], []
+
+ 		# Checks in case user hasn't inputted the right information #Error checks for invalid inputs
+ 		@last_cum = @cum_prob.at(-1)
+
+ 		if @outcome.size != @cum_prob.size
+ 			raise "'prob' arguments must be of same length"
+
+ 		elsif @last_cum != 1
+ 			raise "last value of 2nd argument must be 1"
+		end
+
+		args[1].each{|i|
+				raise "cummulative probability must be between 0 and 1" if 0 > i or i > 1 }
+	end
+	# Calculates the probability of an outcome given its cummulative probability
+	def prob()
+		''' Returns a probability given its cummulative probability '''
+
+		# Starting variables
+		y = 1; @probability.push(@cum_prob[0])
+
+		while y < @cum_prob.size
+			@probability << (@cum_prob[y] - @cum_prob[y-1]).round(4)
+			y+=1
+		end
+
+		return Eventsims.trimval(@probability)
+	end
+
+
+	# Generates a discreteEmp for the given outcome 
+	def discreteemp()
+		'''returns a random number from the outcome list'''
+		#--- generating a random number based on discreteemp
+		
+		emplist = []
+
+		def twoargs()
+			count, number = 0, rand()
+
+			while count < (@cum_prob).size
+				if @cum_prob[count] < number and number <= @cum_prob[count+1]
+					return Eventsims.trimval(@outcome[count+1])
+				
+				elsif 0 <= number and number <= @cum_prob[0]
+				 	return Eventsims.trimval(@outcome[0])
+				end
+				count+=1
+			end
+		end
+	
+		if @args.length == 2
+			return Eventsims.trimval(twoargs())
+
+		elsif @args.length == 3
+			@amount, increment = @args[2], 0
+			if @amount.is_a? (String )
+				raise "Only integers allowed as third argument"
+			end
+			if @amount == 1
+				return Eventsims.trimval(twoargs())
+
+			else
+				#try:
+					while increment < @amount
+						generated = twoargs()
+						if generated.is_a?(Float)
+							generated = Eventsims.trimval(generated)
+						end
+						emplist << (generated)
+						increment +=1
+					end
+				
+				return emplist
+			end
+		end
+	end
+
+	# Calculates the expectation value given its outcome and cummulative probability
+	def expectval()
+		''' returns the expectation value of the outcomes'''
+		
+		expectation, increment, probability = 0,0, prob()
+		
+		while increment < @cum_prob.size
+			expectation += probability[increment] * @outcome[increment]
+			increment += 1
+		end
+
+		if @args.size == 2
+			return Eventsims.trimval(expectation)
+
+		elsif @args.size == 3
+			expectation *= @steps
+			return Eventsims.trimval(expectation)
+
+		else
+			raise "arguments must be two or three"
+		end
+	end
+
+	# Calculates the estimated variance of the given lists
+	def eststddev()
+		'''returns estimated variance of the outcome'''
+		#arguments are: [outcomes], [cummulative probabilities], optional: float(steps)]
+
+		mean = expectval / @steps
+		increment, occurtimes = 0, 0
+		
+		while increment < @cum_prob.size
+			occurtimes += @probability[increment] * (@outcome[increment] - mean)**2
+			increment +=1
+		end
+
+		if @args.size == 2
+			return Eventsims.trimval((occurtimes)**0.5)
+
+		elsif @args.size == 3
+			return Eventsims.trimval(occurtimes**0.5 * @steps**0.5)
+		end
+	end
+
+	def estmean()
+		return expectval
+	end
+
+	# Calculates the estimated standard deviation of the given lists
+	def estvar()
+		''' Returns the estimated standard deviation of the outcome'''
+		#arguments are: [outcomes], [cummulative probabilities], optional: float(steps)]
+		variance = eststddev**2
+		return Eventsims.trimval(variance)
+	end
+
+	end
+
+#end
+end
+

data/lib/eventsims/randgen.rb

@@ -0,0 +1,154 @@
+
+module Randgen
+
+
+# Generating random outcomes and probabilities
+class Generate
+	def initialize(*args)
+		''' Initialisation of all values'''
+		# Starting variables that change result depending on the if statements
+		start, stop, jump = 0, 10, 1
+		@@outcome, @@occur, @@unique, @@problist, @@cumprob = [], [], [], [], []
+		amount = (2..20).step(jump).to_a.sample
+		amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+		
+	# If statements to run different functions
+		if args.size == 0
+			@@outcome = @@outcome
+
+		elsif args.size == 1
+			if args[0].is_a?(Integer) 
+				amount, @@outcome = args[0], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				
+			elsif args[0] == "r"
+				@@outcome.sort!{|x,y| y<=>x}
+
+			elsif args[0] == "s"
+				@@outcome.sort!
+
+			else
+				raise "\nInvalid argument: Use (amount, 'r' or 's')"
+			end
+
+		elsif args.size == 2
+			if args.all?{|x| x.is_a?(Integer)}
+				start, stop, @@outcome = args[0], args[1], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample} 
+				
+			elsif args[1] == "r"
+				amount, @@outcome = args[0], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				@@outcome.sort!{|x,y| y<=>x}
+				
+			elsif args[1] == "s"
+				amount, @@outcome = args[0], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				@@outcome.sort!
+
+			else
+				raise "\nInvalid argument: Use (start, stop) or (amount, 'r' or 's')'"
+			end
+
+		elsif args.size == 3
+			if args.all?{|x| x.is_a?(Integer)}
+				start, stop, amount, @@outcome = args[0], args[1], args[2], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample} 
+				
+			elsif args[2] == "r"
+				start, stop, @@outcome = args[0], args[1], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample} 
+				@@outcome.sort!{|x,y| y<=>x}
+
+			elsif args[2] == "s"
+				start, stop, @@outcome = args[0], args[1], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample} 
+				@@outcome.sort!
+
+			else
+				raise "\nInvalid argument: Use (start, stop, amount) or (amount, 'r' or 's')'"
+			end
+
+		elsif args.size == 4
+			if args.all?{|x| x.is_a?(Integer)}
+				start, stop, jump, amount, @@outcome = args[0], args[1], args[2], args[3], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				
+			elsif args[3] == "r"
+				start, stop, amount, @@outcome = args[0], args[1], args[2], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				@@outcome.sort!{|x,y| y<=>x}
+
+			elsif args[3] == "s"
+				start, stop, amount, @@outcome = args[0], args[1], args[2], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				@@outcome.sort!
+
+			else
+				raise "\nInvalid argument: Use (start, stop, step, amount) or \n\t(start, stop, amount, 'r' or 's')'"
+			end
+
+		elsif args.size == 5	
+			if args[4] == "r"
+				start, stop, jump, amount, @@outcome = args[0], args[1], args[2], args[3], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				@@outcome.sort!{|x,y| y<=>x}
+
+			elsif args[4] == "s"
+				start, stop, jump, amount, @@outcome = args[0], args[1], args[2], args[3], []
+				amount.times{@@outcome << (start..stop).step(jump).to_a.sample}
+				@@outcome.sort!
+
+			else
+				raise "\nInvalid argument: Use (start, stop, step, amount, 'r' or 's')'"
+			end
+		end
+	
+		#Generates a set and times of occurrence ofoutcome
+		@@outcome.each{|item| @@unique << item  unless @@unique.include?(item)}
+		result = @@outcome.each_with_object(Hash.new(0)) { |word, counts| counts[word] += 1 }
+		result.each{|x,y| @@occur << y}
+		
+	end
+
+	# Returns a probability list of all items in its argument
+	def getprob()
+		probability = []
+		'''Returns a probability list of all items in its argument'''
+		@@occur.each{|i| probability << (i*1.0/@@outcome.size).round(4)}
+
+		return probability
+	end
+
+	# Returns a cummulative probability list of all items in its argument
+	def getcum()
+		'''Returns a cummulative probability list of all items in its argument'''
+		increase, probability, cumlist = 0, getprob(), []
+		probability.each{|i| increase +=i
+			cumlist << increase.round(4) }
+		cumlist[-1] = 1.0      #makes sure the last value is 1.0
+		return cumlist
+	end
+
+	# Returns the outcome
+	def outcome()
+		''' Returns a generated outcome '''
+		return @@outcome
+	end
+
+	# Returns the unique outcome
+	def unique()
+		'''Returns the unique outcome'''
+		return @@unique
+	end
+
+# 	# Returns the number of times the unique item is found
+	def occur
+		'''Returns the number of times the unique item is found'''
+		return @@occur
+	end
+
+
+	end
+end
+

data/lib/eventsims/simevent.rb

@@ -0,0 +1,300 @@
+
+module Eventsims
+#module Simevent
+
+class Randomsim
+	def initialize(*args)
+		''' Initialisation '''
+	
+		stop, amount, @_intarrival,  @_service = 10, (2..20).step(1).to_a.sample, [], []
+
+		if args.size == 0
+			amount.times{@_intarrival << (1..stop).step(1).to_a.sample}
+			amount.times{@_service << (1..stop).step(1).to_a.sample}	
+
+		elsif args.size == 1
+			args[0].times{@_intarrival << (1..stop).step(1).to_a.sample}
+			args[0].times{@_service << (1..stop).step(1).to_a.sample}	
+
+		elsif args.size == 2
+			args[1].times{@_intarrival << (1..args[0]).step(1).to_a.sample}
+			args[1].times{@_service << (1..args[0]).step(1).to_a.sample}	
+
+		elsif args.size == 3
+			args[2].times{@_intarrival << (1..args[0]).step(1).to_a.sample}
+			args[2].times{@_service << (1..args[1]).step(1).to_a.sample}
+
+		else
+			raise "Arguments must be between 0 to 3"
+		end
+
+		#Sets its first value to zero
+		@_intarrival[0] = 0
+
+		# Required variables
+		@_arrival, @_preservstart, @_servstart = [], [0], []
+		@_queue, @_servend, @_custspend, @_idle = [], [], [], [0]
+
+		def getarrive_()
+			'''Returns arrival time'''
+			increase = 0
+			@_intarrival.each {|i| increase +=i
+				@_arrival << increase }
+			return @_arrival
+		end
+		
+		def servbegins_()
+			'''Returns time when service begin'''
+			increase = 0
+			i = 0; while i < @_service.size
+				increase+= @_service[i]
+				@_preservstart << increase
+				i+=1
+			end
+			@_preservstart.pop
+			return @_preservstart
+		end
+
+		#populate @_servend with values. just to get same size
+		@_intarrival.each{|i| @_servend << i}
+			
+		#Please maintain order if you are editing the code!
+		# Calling functions
+		getarrive_()	#Returns arrival time
+		servbegins_()	#Returns time when servce begin
+
+		def get_servend_()
+			'''Retuns time when service ends'''
+			x = 0; while x < ((@_preservstart).size)
+				@_servend[x] = @_preservstart[x] + @_service[x]
+				s = 1; while s < (@_preservstart).size
+					if @_preservstart[s] < (maximum = @_arrival[s] > @_servend[x]? @_arrival[s] : @_servend[x])
+						@_preservstart[s] = (maximum)
+					end
+					s+=1 
+				end
+				x+=1
+			end
+
+			return @_servend
+		end
+
+		# Method used to calculate the rest of the data like
+		#time when service begins
+		#wait time in queue, (_queue)
+		#time customer spent in the system (_custspend)
+		def otherresults(list1, list2, list3)
+			''' Stores and return the value of (list2 - list3) in list1 '''
+			x = 0; while x < list2.size
+				list1 << (list2[x] - list3[x]) 
+				x+=1
+			end
+			list1[0] = 0 if list1[0] < 0	
+		end
+
+		def idletime_()
+			'''Returns the idle time of server'''
+			x,y = 0,1
+			while y < @_servend.size
+				(@_idle) << (@_servstart[y] - @_servend[x])
+				x+=1; y+=1
+			end
+			return @_idle
+		end
+
+		# Calling other methods
+		get_servend_()
+		otherresults(@_servstart, @_servend, @_service) 
+		otherresults(@_queue, @_servstart, @_arrival) 
+		otherresults(@_custspend, @_servend, @_arrival)
+		idletime_()
+	end
+
+	#Methods to be used outside of initialize returning necessary values
+	#Main methods
+	
+	def intarrival()
+		'''Returns the interarrival time'''
+		return @_intarrival
+	end
+
+	def arrival()
+		'''Returns the arrival time'''
+		return @_arrival
+	end
+
+	def service()
+		'''Returns the service time'''
+		return @_service
+	end
+
+	def servbegin()
+		'''Returns the time when service began'''
+		return @_servstart
+	end
+
+	def queuewait()
+		"""Returns the customer's waiting time in the queue"""
+		return @_queue
+	end
+
+	def servend()
+		'''Returns the time service ended'''
+		return @_servend
+ 	end
+
+	def custspend()
+		'''Returns the time customer spends in system'''
+		return @_custspend
+	end
+
+	def idle()
+		'''Returns the idle time of server'''
+		return @_idle
+	end
+
+end
+
+
+class Simulate < Randomsim
+	def initialize(*args)
+		''' Initialisation '''
+
+		stop, amount = 10, (2..20).step(1).to_a.sample
+		@_intarrival, @_service = [], []
+
+		if args.size == 1
+			@_intarrival = args[0]
+			raise "Argument must be a list" unless args[0].is_a?(Array)	
+			(args[0].size).times{@_service << (1..stop).step(1).to_a.sample}	
+
+			args[0].each{|y| 
+				raise "Only numbers allowed in Arrays" if y.is_a?(String) } 
+			
+		elsif args.size == 2
+			#checks if both arguments are arrays
+			unless args.all?{|x| x.is_a?(Array)	}
+				raise "Argument one and two must be Arrays"  
+			end
+			@_intarrival = args[0]
+			@_service = args[1]
+		
+			args[0].each{|y| 
+				raise "Only numbers allowed in Arrays" if y.is_a?(String) } 
+			args[1].each{|y| 
+				raise "Only numbers allowed in Arrays" if y.is_a?(String) } 
+			
+			#Check length of both lists and throw error if not equal
+			if args[0].size != args[1].size
+				raise "List arguments must be of equal length"
+			end
+
+		else
+			raise "You must supply one or two Array arguments"
+		end
+
+		# If first value less than 0 set it to zero
+		@_intarrival[0] = 0 if @_intarrival[0] < 0
+			
+		# Required variables and input error handling
+		@_preservstart = []; @_preservstart << args[0][0]
+		@_preservstart[0] = 0 if @_preservstart[0] < 0
+
+		# Other variable declaration
+		@_arrival, @_servstart, @_queue = [], [], []
+		@_servend, @_custspend, @_idle = [], [], [0]
+
+		# Makes display less annoying
+		def makenice(thelist)
+			temp = []
+			thelist.each{|i| if i.is_a?(Integer)
+				temp << i
+				else
+					temp << i.round(4) 
+				end  }
+			thelist = temp
+			return thelist
+		end
+
+		def getarrive_()
+			'''Returns arrival time'''
+			increase = 0
+			@_intarrival.each{|i| increase +=i
+				@_arrival << increase  }
+			return @_arrival
+		end
+
+		def servbegins_()
+			'''Returns time when service begin'''
+			increase, i = 0, 0
+			while i < @_service.size
+				increase += @_service[i]
+				@_preservstart << increase
+				i+=1
+			end
+			@_preservstart.pop()
+
+			return @_preservstart
+		end
+
+		#populate @_servend with values. just to get same size
+		@_intarrival.each{|i| @_servend << i}
+
+		# #Please maintain order if you are editing the code!
+		# # Calling functions
+		getarrive_()	#Returns arrival time
+		servbegins_()	#Returns time when servce begin
+
+		def get_servend_()
+			'''Retuns time when service ends'''
+			x = 0; while x < ((@_preservstart).size)
+				@_servend[x] = @_preservstart[x] + @_service[x]
+				s = 1; while s < (@_preservstart).size
+					if @_preservstart[s] < (maximum = @_arrival[s] > @_servend[x]? @_arrival[s] : @_servend[x])
+						@_preservstart[s] = (maximum)
+					end
+					s+=1 
+				end
+				x+=1
+			end
+
+			return @_servend
+		end
+
+		# Method used to calculate the rest of the data like
+		#time when service begins
+		#wait time in queue, (_queue)
+		#time customer spent in the system (_custspend)
+		def otherresults(list1, list2, list3)
+			''' Stores and return the value of (list2 - list3) in list1 '''
+			x = 0; while x < list2.size
+				list1 << (list2[x] - list3[x]) 
+				x+=1
+			end
+			list1[0] = 0 if list1[0] < 0	
+		end
+
+		def idletime_()
+			'''Returns the idle time of server'''
+			x,y = 0,1
+			while y < @_servend.size
+				(@_idle) << (@_servstart[y] - @_servend[x])
+				x+=1; y+=1
+			end
+			return @_idle
+		end
+
+		# Calling other methods
+		get_servend_()
+		otherresults(@_servstart, @_servend, @_service) 
+		otherresults(@_queue, @_servstart, @_arrival) 
+		otherresults(@_custspend, @_servend, @_arrival)
+		idletime_()
+	end
+	#Simulation class will inherit methods from the Randomsim class
+
+end
+
+#end
+end
+

data/lib/eventsims/version.rb

@@ -0,0 +1,22 @@
+module Eventsims
+  VERSION = "0.0.1"
+end
+
+#Files
+# --> 1 = discrete.rb
+# --> 2 = randgen.rb
+# --> 3 = simevent.rb
+
+#All Eventsim methods
+#1. trimval,   --> 1
+#2. trimlist,  --> 1
+
+#All Eventsim classes
+#3. Calculate  --> 1
+#4 Generate    --> 2
+#5. Randomsim  --> 3
+#6. Simulate   --> 3
+
+#####################
+#5. Simtable --> 3	# not implemented
+#####################

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: eventsims
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Taiwo Kareem
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 'Eventsims is a Ruby package for simulating discrete event. It has  four
+  classes (Calculate, Generate, Randomsim and Simulate) and two methods(trimval and
+  trimlist) for making this possible. '
+email:
+- taiwo.kareem36@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .Gemfile.lock.swp
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- eventsims.gemspec
+- lib/eventsims.rb
+- lib/eventsims/discrete.rb
+- lib/eventsims/randgen.rb
+- lib/eventsims/simevent.rb
+- lib/eventsims/version.rb
+homepage: http://github.com/tushortz/eventsims
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Eventsims uses various useful tools in simulating discrete system events
+  based on outcome and probabilities
+test_files: []