eventsims 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c14a98f8416741099ed89150135a0fcb2875cb1a
-  data.tar.gz: edb09fc49abceb6650406dbb0cbf1c23d02bbbf8
+  metadata.gz: 370638fef8adbe673a198d43a1a1d3b20aded8e2
+  data.tar.gz: 42eeacce80ec2af8803d424513ddd742de8ed42f
 SHA512:
-  metadata.gz: 5b944852af53fccc3b5b1d70ee041a2dce356b9d63f25c1dc730e277e7e5480b3f0a31a10f03eda1bf3239e4e5631d749265aed1b995e371670a20df170b4616
-  data.tar.gz: 1c2ef1840388301c1795bc43eab208c40713ae8398e12bee73cc600a77d418006b2933e7554812a83fa8ab7f9c4c9871be02cc314b1ae00c5868515f8f0f730d
+  metadata.gz: daa9a3896a416c6a45765027c3bab9401d3842754c8b28f1ce88ee4bd08154e939bd352c5fe0147be69bcf56054a79031d80dbfb3a29155a896b077030c0e649
+  data.tar.gz: 5b196815dec082248f99d2b86a3bba3361cbc2fb0acc76eb3de855dfbf53afb29384371a49838cb106c41a424b9db0ca1454ad97412dced222828617b19547d7

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    eventsims (0.0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  eventsims!
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.10.6

data/README.md

@@ -1,22 +1,41 @@
 # Eventsims
 
 ## Description
+Eventsims is a Ruby package that uses various useful tools in simulating discrete system events based on outcome and probabilities easily. 
 
-Eventsims contains various useful tools to makes discrete event easy to simulate.
+## Requirements
+* Any version of Ruby
 
+## Installation
+Add this line to your application's Gemfile:
 
-# MODULE NAME --> Eventsims
+```ruby
+gem 'eventsims'
+```
 
+And then execute:
 
-## Module Classes
+    $ bundle
 
+Or install it yourself as:
 
-### Calculate 
+    $ gem install eventsims
 
-**Calculate** takes two list Arrays (outcome, cummulative probability) as arguments and an optional integer value `(steps)` for simplifying and calculating several data.
+
+## Module name --> Eventsims
+It contains four main classes and two methods.
+
+## Module Classes
+
+### Calculate
+**Calculate** has six methods for calculating/generating ``probability``, ``estimated variance``, ``estimated mean``, ``estimated standard deviation``, ``expectation value`` and ``discreteEmp``.
+
+Eventsims' "`Calculate` class" takes `two arguments`: ``outcome`` and ``cummulative probability`` or a third optional argument which is `amount of times to be generated` (``steps``). 
 
 #### Methods
 
+Calculate methods are:
+
 * 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
@@ -24,162 +43,704 @@ Eventsims contains various useful tools to makes discrete event easy to simulate
 * estvar() ----> To calculate the estimated variance of the list data
 * eststddev ----> To calculate the estimated standard deviation of the list data
 
-#### Usage Example
 
-```
+#### Usage 
+You can use the Calculate class in the following way:
+
+##### Example 1
+
+**Two arguments** 
+
+Usage: Calculate.new(**outcome list**, **cummulative probability list**)
+
+
+```ruby
 require "Eventsims"
 
-sample = Eventsims::Calculate.new([-1, 0, 3, 4], [0.1, 0.4, 0.7, 1], 10)
+sample = Eventsims::Calculate.new(a, b)
+
+a = [-1,0,3,4]
+b = [0.1, 0.4, 0.7, 1]
+
+puts "Probability: #{sample.prob()}" 
+puts "DiscreteEmp: #{sample.discreteemp()}" 
+puts "Expectation value: #{sample.expectval()}" 
+puts "Estimated Mean: #{sample.estmean()}" 
+puts "Estimated Variance: #{sample.estvar()}" 
+puts "Estimated Standard deviation: #{sample.eststddev()}" 
+```
+
+##### Result 1
+
 
-puts "probability: #{sample.prob()}"
-puts "Arrival time: #{sample.discreteemp()}"
-puts "Estimated standard deviation: #{sample.eststddev()}"
-puts "Estimated mean: #{sample.estmean()}"
+```ruby
+Probability: [0.1, 0.3, 0.3, 0.3]
+DiscreteEmp: 3
+Expectation value: 2.0
+Estimated Mean: 2.0
+Estimated Variance: 3.6
+Estimated Standard deviation: 1.8974
 ```
-#### Result
+
+##### Example 2
+
+**three arguments**
+
+Usage: Calculate.new(**outcome list**, **cummulative probability list**, "`Optional: amount/steps`")
+
+```ruby
+require "Eventsims" 
+
+a = [-1,0,3,4]
+b = [0.1, 0.4, 0.7, 1]
+
+sample = Eventsims::Calculate.new(a, b, 10)
+
+puts "Probability: #{sample.prob() }" 
+puts "DiscreteEmp: #{sample.discreteemp() }" 
+puts "Expectation value: #{sample.expectval() }" 
+puts "Estimated Mean: #{sample.estmean() }" 
+puts "Estimated Variance: #{sample.estvar() }" 
+puts "Estimated Standard deviation: #{sample.eststddev() }"
 ```
-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
+
+##### Result 2
+
+```ruby
+Probability: [0.1, 0.3, 0.3, 0.3]
+DiscreteEmp: [3, 0, 4, 4, 4, 4, 3, 0, 0, 0]
+Expectation value: 20.0
+Estimated Mean: 20.0
+Estimated Variance: 36.0
+Estimated Standard deviation: 6.0
 ```
 
+
+> **argument one** of the Calculate class should be the **outcome** list while **argument two** should be the **cummulative probability** list. **Argument three (steps)** is optional and only needed if any of the data is to be calculated after a certain number of times or to generate a list of discreteEmp values. 
+
+> If no optional argument is given (same as if an optional argument is set to 1), discreteemp will generate only one outcome but if more the optional argument is more than one e.g. 5, then *discreteemp* will generate a list containing several generated outcomes (5 items in a list in this case).
+
+
+
 ### 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.
+**Generate** takes integer values as arguments (from `no arguments` up to and including `five arguments`) with optional `string` arguments being **"r"** or **"s"**. **r** for **reverse (descending order) ** sorting and **s** for **ascending order** sorting. It has five methods which can be called on its instance namely:
 
-* 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.
+#### Methods
 
-#### Usage example
-```
+* 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
+
+You can use the Generate class in the following ways:
+
+> The following examples will cover how arguments are used in the Generate class. In the examples, we assume that the class has been required first as
+
+```ruby
 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()}")
+##### Example 1a
+
+**zero arguments**
+
+Usage: Eventsims::Generate.new()
+
+What this does is populate the outcome list with random values (between 0 and 10) the default amount of times (i.e. a random number between 2 and 20).
+
+```ruby
+sample = Eventsims::Generate.new()
+
+puts "Outcome: #{sample.outcome() }"
+puts "Unique Outcome: #{sample.unique() }" 
+puts "Occurrence: #{sample.occur() }" 
+puts "Probability: #{sample.getprob() }" 
+puts "Cummulative Probability: #{sample.getcum() }" 
+```
+
+##### Result 1a
 
+```ruby
+Outcome: [10, 4, 0, 5, 5, 2, 8, 4]
+Unique Outcome: [10, 4, 0, 5, 2, 8]
+Occurrence: [1, 2, 1, 2, 1, 1]
+Probability: [0.25, 0.5, 0.25, 0.5, 0.25, 0.25]
+Cummulative Probability: [0.25, 0.75, 1.0, 1.5, 1.75, 1.0]
 ```
 
-#### Result
+##### Example 1b
+
+**Optional string argument**
+
+Usage: Eventsims::Generate.new('optional: **sort** ')
+
+Adding an optional string argument *"r"* will *sort* the *outcome* in *descending* order whereas using the *"s"* string argument will *sort* the *outcome* in *ascending* order
+
+```ruby
+sample = Eventsims::Generate.new("r")
+
+puts "Outcome: #{sample.outcome() }"
+puts "Unique Outcome: #{sample.unique() }"
+puts "Occurrence: #{sample.occur() }"
+puts "Probability: #{sample.getprob() }"
+puts "Cummulative Probability: #{sample.getcum() }"
+```
+
+##### Result 1b
+```ruby
+Outcome: [5, 3, 2, 2, 1]
+Unique Outcome: [5, 3, 2, 1]
+Occurrence: [1, 1, 2, 1]
+Probability: [0.2, 0.2, 0.4, 0.2]
+Cummulative Probability: [0.2, 0.4, 0.8, 1.0]
+```
+
+##### Example 2a
+
+**one argument**
+
+Usage: Eventsims::Generate.new(**amount**)
+
+What this does is populate the outcome list with random values (between 0 and 10) the amount of times specified in the argument. For example if 10 was specified in the argument, it will populate the outcome list with values ten times
+
+```ruby
+sample = Eventsims::Generate.new(8)
+
+puts "Outcome: #{sample.outcome() } "
+puts "Unique Outcome: #{sample.unique() } "
+puts "Occurrence: #{sample.occur() } "
+puts "Probability: #{sample.getprob() } "
+puts "Cummulative Probability: #{sample.getcum() } "
+```
+
+##### Result 2a
+```ruby
+Outcome: [8, 4, 8, 1, 2, 9, 2, 9]
+Unique Outcome: [8, 4, 1, 2, 9]
+Occurrence: [2, 1, 1, 2, 2]
+Probability: [0.25, 0.125, 0.125, 0.25, 0.25]
+Cummulative Probability: [0.25, 0.375, 0.5, 0.75, 1.0
+```
+
+##### Example 2b
+
+**Optional string argument**
+
+Usage: Eventsims::Generate.new(**amount**, 'optional: **sort**')
+
+Adding an optional string argument *"r"* will *sort* the *outcome* in *descending* order whereas using the *"s"* string argument will *sort* the *outcome* in *ascending* order
+
+```ruby
+sample = Eventsims::Generate.new(10,"s")
+
+puts "Outcome: #{sample.outcome() } "
+puts "Unique Outcome: #{sample.unique() } "
+puts "Occurrence: #{sample.occur() } "
+puts "Probability: #{sample.getprob() } "
+puts "Cummulative Probability: #{sample.getcum() } "
+
+```
+
+##### Result 2b
+```ruby
+Outcome: [0, 1, 1, 1, 3, 4, 7, 7, 9, 10]
+Unique Outcome: [0, 1, 3, 4, 7, 9, 10]
+Occurrence: [1, 3, 1, 1, 2, 1, 1]
+Probability: [0.1, 0.3, 0.1, 0.1, 0.2, 0.1, 0.1]
+Cummulative Probability: [0.1, 0.4, 0.5, 0.6, 0.8, 0.9, 1.0]
+```
+
+##### Example 3a
+
+**two arguments**
+
+Usage: Eventsims::Generate.new(**start**, **stop**)
+
+What this does is populate the outcome list with values (between argument one and argument two) the default amount of times (i.e. a random number between 2 and 20).
+
+```ruby
+sample = Eventsims::Generate.new(3, 7)
+
+puts "Outcome: #{sample.outcome() } "
+puts "Unique Outcome: #{sample.unique() } "
+puts "Occurrence: #{sample.occur() } "
+puts "Probability: #{sample.getprob() } "
+puts "Cummulative Probability: #{sample.getcum() } "
+
+```
+##### Result 3a
+```ruby
+Outcome: [4, 7, 7, 4, 3, 3, 4, 4]
+Unique Outcome: [4, 7, 3]
+Occurrence: [4, 2, 2]
+Probability: [0.5, 0.25, 0.25]
+Cummulative Probability: [0.5, 0.75, 1.0]
+```
+
+
+##### Example 3b
+
+**Optional string argument**
+
+Usage: Eventsims::Generate.new(**start**, **stop**, 'optional: **sort** ')
+
+Adding an optional string argument *"r"* will *sort* the *outcome* in *descending* order whereas using the *"s"* string argument will *sort* the *outcome* in *ascending* order
+
+```ruby
+sample = Eventsims::Generate.new(2, 6, "r")
+
+puts "Outcome: #{sample.outcome() } "
+puts "Unique Outcome: #{sample.unique() } "
+puts "Occurrence: #{sample.occur() } "
+puts "Probability: #{sample.getprob() } "
+puts "Cummulative Probability: #{sample.getcum() } "
+
+```
+
+##### Result 3b
+
+```ruby
+Outcome: [6, 5, 5, 5, 4, 4, 4, 4, 2, 2]
+Unique Outcome: [6, 5, 4, 2]
+Occurrence: [1, 3, 4, 2]
+Probability: [0.1, 0.3, 0.4, 0.2]
+Cummulative Probability: [0.1, 0.4, 0.8, 1.0]
+```
+
+##### Example 4a
+
+**three arguments**
+
+Usage: Eventsims::Generate.new(**start**, **stop**, **amount**)
+
+What this does is populate the outcome list with values (between argument one and argument two) the amount of times supplied in argument three. i.e. if 4 was supplied as the third argument, there will be four values in the outcome list.
+
+```ruby
+sample = Eventsims::Generate.new(2, 5, 7)
+
+puts "Outcome: #{sample.outcome() } "
+puts "Unique Outcome: #{sample.unique() } "
+puts "Occurrence: #{sample.occur() } "
+puts "Probability: #{sample.getprob() } "
+puts "Cummulative Probability: #{sample.getcum() } "
+
+```
+##### Result 4a
+
+```ruby
+Outcome: [5, 5, 4, 4, 4, 2, 3]
+Unique Outcome: [5, 4, 2, 3]
+Occurrence: [2, 3, 1, 1]
+Probability: [0.2857, 0.4286, 0.1429, 0.1429]
+Cummulative Probability: [0.2857, 0.7143, 0.8572, 1.0]
+```
+
+##### Example 4b
+
+**Optional string argument**
+
+Usage: Eventsims::Generate.new(**start**, **stop**, **amount**, 'optional: **sort** ')
+
+Adding an optional string argument *"r"* will *sort* the *outcome* in *descending* order whereas using the *"s"* string argument will *sort* the *outcome* in *ascending* order
+
+```ruby
+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 4b
+
+```ruby
 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
 
+##### Example 5a
 
-#### 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)
+**four 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
+Usage: Eventsims::Generate.new(**start**, **stop**, **step**, **amount**)
 
+What this does is populate the outcome list with values (between argument one and argument two) in steps of argument three value the amount of times in argument four's value. 
 
-#### Methods
+```ruby
+sample = Eventsims::Generate.new(2, 20, 3, 10)
+
+puts "Outcome: #{sample.outcome() } "
+puts "Unique Outcome: #{sample.unique() } "
+puts "Occurrence: #{sample.occur() } "
+puts "Probability: #{sample.getprob() } "
+puts "Cummulative Probability: #{sample.getcum() } "
+
+```
+
+##### Result 5a
+
+```ruby
+Outcome: [20, 8, 11, 5, 11, 17, 20, 17, 14, 20]
+Unique Outcome: [20, 8, 11, 5, 17, 14]
+Occurrence: [3, 1, 2, 1, 2, 1]
+Probability: [0.3, 0.1, 0.2, 0.1, 0.2, 0.1]
+Cummulative Probability: [0.3, 0.4, 0.6, 0.7, 0.9, 1.0]
+```
+
+
+##### Example 5b
+
+**Optional string argument**
+
+Usage: Eventsims::Generate.new(**start**, **stop**, **step**, **amount**, 'optional: **sort** ')
+
+Adding an optional string argument *"r"* will *sort* the *outcome* in *descending* order whereas using the *"s"* string argument will *sort* the *outcome* in *ascending* order
 
-* 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).
+```ruby
+sample = Eventsims::Generate.new(2, 20, 3, 10, "r")
+
+puts "Outcome: #{sample.outcome() } "
+puts "Unique Outcome: #{sample.unique() } "
+puts "Occurrence: #{sample.occur() } "
+puts "Probability: #{sample.getprob() } "
+puts "Cummulative Probability: #{sample.getcum() } "
 
+```
 
+##### Result 5b
 
-#### Usage Example
+```ruby
+Unique Outcome: [20, 17, 14, 11, 8, 5, 2]
+Occurrence: [3, 1, 1, 1, 1, 1, 2]
+Probability: [0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.2]
+Cummulative Probability: [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 1.0]
 ```
+
+
+### Randomsim
+
+**Randomsim** helps to quickly simulate and generate a scenario with random values by just passing your desired argument values into it. It takes between 0 to 3 arguments. The generated results are then stored into the inter-arrival time and service time list needed to generate the rest of the values.
+
+#### Methods
+
+This class has eight methods that can be called on its instance namely:
+
+* 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
+You can use the Randomsim class the following ways:
+
+
+> The following examples will cover how arguments are used in the Generate class. In the examples, we assume that the class has been required first as
+
+```ruby
 require "Eventsims"
+```
+
+and you can then respectively use it like in the following examples:
 
-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()}"
+##### Example 1a
+
+**zero arguments**
+
+What this does is populate the inter-arrival and service time list with random numbers (between 1 and 10) random amount of times (2 to 20). The first value of the inter-arrival time defaults to 0.
+
+```ruby
+
+sample = Eventsims::Randomsim.new()
+ 
+puts "Inter-arrival time: #{sample.intarrival() } "
+puts "Arrival time: #{sample.arrival() } "
+puts "Service time: #{sample.service() } "
+puts "Time when Service begins: #{sample.servbegin() } "
+puts "Time when Service ends: #{sample.servend() } "
+puts "Time customer spends waiting in Queue: #{sample.queuewait() } "
+puts "Time customer spends in system: #{sample.custspend() } "
+puts "Idle time of server: #{sample.idle() } "
 ```
 
-#### Result
+##### Result 1a
+
+```ruby
+Inter-arrival time: [0, 8, 4, 10, 1]
+Arrival time: [0, 8, 12, 22, 23]
+Service time: [2, 9, 4, 5, 5]
+Time when Service begins: [0, 8, 17, 22, 27]
+Time when Service ends: [2, 17, 21, 27, 32]
+Time customer spends waiting in Queue: [0, 0, 5, 0, 4]
+Time customer spends in system: [2, 9, 9, 5, 9]
+Idle time of server: [0, 6, 0, 1, 0]
 ```
-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]
+
+
+##### Example 1b
+
+**one argument**
+
+Usage: Eventsims::Randomsim.new(**list size**)
+
+What this does is populate the inter-arrival and service time list with random numbers (between 1 and 10) the amount of times supplied as the only argument value. The first value of the inter-arrival time defaults to 0.
+
+```ruby
+sample = Eventsims::Randomsim.new(6)
+ 
+puts "Inter-arrival time: #{sample.intarrival() }"
+puts "Arrival time: #{sample.arrival() }"
+puts "Service time: #{sample.service() }"
+puts "Time when Service begins: #{sample.servbegin() }"
+puts "Time when Service ends: #{sample.servend() }"
+puts "Time customer spends waiting in Queue: #{sample.queuewait() }"
+puts "Time customer spends in system: #{sample.custspend() }"
+puts "Idle time of server: #{sample.idle() }"
 ```
 
-## Module methods
-###trimval
+##### Result 1b
 
-**trimval** that takes in one argument, (numbers or lists and strips it of leading zeros and round up to 4 decimal places 
 
-## trimlist
+```ruby
+Inter-arrival time: [0, 4, 10, 9, 1, 9]
+Arrival time: [0, 4, 14, 23, 24, 33]
+Service time: [4, 10, 1, 8, 10, 5]
+Time when Service begins: [0, 4, 14, 23, 31, 41]
+Time when Service ends: [4, 14, 15, 31, 41, 46]
+Time customer spends waiting in Queue: [0, 0, 0, 0, 7, 8]
+Time customer spends in system: [4, 10, 1, 8, 17, 13]
+Idle time of server: [0, 0, 0, 8, 0, 0]
+```
+
 
-**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.
+##### Example 1c
+
+**two 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: Eventsims::Randomsim.new(**max value**, **list size**)
 
-#### Usage example
+What this does is populate the inter-arrival and service time list with numbers not more than the first argument starting from 1. The list is populated the amount of times specified as the second argument.
+
+```ruby
+sample = Eventsims::Randomsim.new(4,6)
+ 
+puts "Inter-arrival time: #{sample.intarrival() }"
+puts "Arrival time: #{sample.arrival() }"
+puts "Service time: #{sample.service() }"
+puts "Time when Service begins: #{sample.servbegin() }"
+puts "Time when Service ends: #{sample.servend() }"
+puts "Time customer spends waiting in Queue: #{sample.queuewait() }"
+puts "Time customer spends in system: #{sample.custspend() }"
+puts "Idle time of server: #{sample.idle() }"
 ```
-require "Eventsims"
 
-sample = Eventsims.trimval([3.6789876])
-puts "new value: #{sample}"
 
+##### Result 1c
 
-sample = Eventsims.trimlist([3.6789876], "dog", [2.76542, "rat", [4]])
-puts "new list: #{sample}"
+```ruby
+Inter-arrival time: [0, 1, 2, 2, 2, 4]
+Arrival time: [0, 1, 3, 5, 7, 11]
+Service time: [1, 2, 1, 4, 2, 4]
+Time when Service begins: [0, 1, 3, 5, 9, 11]
+Time when Service ends: [1, 3, 4, 9, 11, 15]
+Time customer spends waiting in Queue: [0, 0, 0, 0, 2, 0]
+Time customer spends in system: [1, 2, 1, 4, 4, 4]
+Idle time of server: [0, 0, 0, 1, 0, 0]
 ```
-	
-#### Result
+
+
+##### Example 1d
+
+**three arguments**
+
+Usage: Eventsims::Randomsim.new(**max value for inter-arrival time**, **max value for service time**, **list size**)
+
+What this does is populate the inter-arrival with numbers between 1 and the value passed into the first argument, service time is populated with values between 1 and the second argument while the third argument is the amount/size of the two lists.
+
+```ruby
+sample = Eventsims::Randomsim.new(4, 6, 8)
+ 
+puts "Inter-arrival time: #{sample.intarrival() } "
+puts "Arrival time: #{sample.arrival() } "
+puts "Service time: #{sample.service() } "
+puts "Time when Service begins: #{sample.servbegin() } "
+puts "Time when Service ends: #{sample.servend() } "
+puts "Time customer spends waiting in Queue: #{sample.queuewait() } "
+puts "Time customer spends in system: #{sample.custspend() } "
+puts "Idle time of server: #{sample.idle() } "
 ```
-new val: [[3.679]]
-new list: [[3.679], "dog", [2.7654, "rat", [4]]
+
+
+##### Result 1d
+
+
+```ruby
+Inter-arrival time: [0, 3, 2, 2, 3, 3, 3, 4]
+Arrival time: [0, 3, 5, 7, 10, 13, 16, 20]
+Service time: [6, 2, 2, 2, 4, 5, 6, 4]
+Time when Service begins: [0, 6, 8, 10, 12, 16, 21, 27]
+Time when Service ends: [6, 8, 10, 12, 16, 21, 27, 31]
+Time customer spends waiting in Queue: [0, 3, 3, 3, 2, 3, 5, 7]
+Time customer spends in system: [6, 5, 5, 5, 6, 8, 11, 11]
+Idle time of server: [0, 0, 0, 0, 0, 0, 0, 0]
 ```
 
-## Requirements
 
+### Simulate
 
-* Any version of Ruby
+**Simulate** helps to quickly simulate and generate a scenario with user-defined values. It is more flexible in that it allows you to input your own data rather than input just numbers as compared to **Randomsim**. It can take one or two arguments which are inter-arrival time list and service time list. They must be of the same length.
 
+#### Methods
 
-## Installation
+This class has eight methods (same as `Randomsim`) that can be called on its instance namely:
+
+* 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).
 
-Add this line to your application's Gemfile:
+
+#### Usage
+
+>The following examples will cover how arguments are used in the Simulate class. In the examples, we assume that the class has been required first as:
 
 ```ruby
-gem 'eventsims'
+require "Eventsims"
 ```
 
-And then execute:
+##### Example 2a
 
-    $ bundle
+**one argument**
 
-Or install it yourself as:
+Usage: Eventsims::Simulate.new(**inter-arrival list**)
 
-    $ gem install eventsims
+What this does is populate the inter-arrival time with the user-defined argument (**must be a list**) and service time would be automatically generated (populated with numbers between 1 and 10 with the same size as inter-arrival time). 
+
+```ruby
+sample = Eventsims::Simulate.new([7, 9, 6])
+ 
+puts "Inter-arrival time: #{sample.intarrival() } "
+puts "Arrival time: #{sample.arrival() } "
+puts "Service time: #{sample.service() } "
+puts "Time when Service begins: #{sample.servbegin() } "
+puts "Time when Service ends: #{sample.servend() } "
+puts "Time customer spends waiting in Queue: #{sample.queuewait() } "
+puts "Time customer spends in system: #{sample.custspend() } "
+puts "Idle time of server: #{sample.idle() } "
+```
+
+##### Result 2a
+
+```ruby
+Inter-arrival time: [7, 9, 6]
+Arrival time: [7, 16, 22]
+Service time: [2, 5, 1]
+Time when Service begins: [7, 16, 22]
+Time when Service ends: [9, 21, 23]
+Time customer spends waiting in Queue: [0, 0, 0]
+Time customer spends in system: [2, 5, 1]
+Idle time of server: [0, 7, 1]
+```
+
+
+##### Example 2b
+
+**two arguments**
 
+Usage: Eventsims::Randomsim.new(**inter-arrival list**, **service time list**)
+
+What this does is populate the inter-arrival with the first list argument and the service time with the second argument which is then used to calcuate the the rest.
+
+```ruby
+sample = Eventsims::Simulate.new([0, 5, 6, 3, 7, 9, 3], [4, 7, 2, 1, 3, 11, 7])
+
+puts "Inter-arrival time: #{sample.intarrival() } "
+puts "Arrival time: #{sample.arrival() } "
+puts "Service time: #{sample.service() } "
+puts "Time when Service begins: #{sample.servbegin() } "
+puts "Time when Service ends: #{sample.servend() } "
+puts "Time customer spends waiting in Queue: #{sample.queuewait() } "
+puts "Time customer spends in system: #{sample.custspend() } "
+puts "Idle time of server: #{sample.idle() } "
+```
 
+##### Result 2b
 
-## Development
+
+```ruby
+Inter-arrival time: [0, 5, 6, 3, 7, 9, 3]
+Arrival time: [0, 5, 11, 14, 21, 30, 33]
+Service time: [4, 7, 2, 1, 3, 11, 7]
+Time when Service begins: [0, 5, 12, 14, 21, 30, 41]
+Time when Service ends: [4, 12, 14, 15, 24, 41, 48]
+Time customer spends waiting in Queue: [0, 0, 1, 0, 0, 0, 8]
+Time customer spends in system: [4, 7, 3, 1, 3, 11, 15]
+Idle time of server: [0, 1, 0, 0, 6, 6, 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(Array) keeping it concise. `
+
+#### Usage
+
+Usage: Eventsims::trimval(**single argument**)
+Usage: Eventsims::trimlist(**any Array argument**)
+
+##### example
+```ruby
+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
+```ruby
+new val: [[3.679]]
+new list: [[3.679], "dog", [2.7654, "rat", [4]]
+```
+
+
+
+<!-- ## 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.
@@ -188,4 +749,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/tushor
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/eventsims/randgen.rb

@@ -1,5 +1,5 @@
 
-module Randgen
+module Eventsims
 
 
 # Generating random outcomes and probabilities

data/lib/eventsims/version.rb

@@ -1,6 +1,7 @@
 module Eventsims
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end
+		
 
 #Files
 # --> 1 = discrete.rb

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: eventsims
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Taiwo Kareem
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-07-30 00:00:00.000000000 Z
+date: 2015-07-31 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
@@ -47,10 +47,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .Gemfile.lock.swp
-- .gitignore
-- .rspec
+- ".rspec"
 - Gemfile
+- Gemfile.lock
 - Guardfile
 - LICENSE.txt
 - README.md
@@ -63,6 +62,7 @@ files:
 - lib/eventsims/randgen.rb
 - lib/eventsims/simevent.rb
 - lib/eventsims/version.rb
+- pkg/eventsims-0.0.1.gem
 homepage: http://github.com/tushortz/eventsims
 licenses:
 - MIT
@@ -73,17 +73,17 @@ 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
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Eventsims uses various useful tools in simulating discrete system events

data/.gitignore

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