random_variate_generator 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 783e457a4195aed607feeed3b41432a906d423fa
+  data.tar.gz: c0667a533666ddc64a0a05d730a4ff9180615ed0
+SHA512:
+  metadata.gz: d3bff27c61c62a16cce9f323b6d3431131bc6e5c4941432c17f5b26378dbb16ac90f978effbb49ca62c2a2ad2e8f0976d9e4ce5b98839ff31d4b3562628a18e7
+  data.tar.gz: 0572ec13ed4254ef8489ba6d670363a95d1a1c60daf507d7bf6eb3df796fc58e02db9da6d586491671ed64890658db38d931405165b46e48e26c38b150766622

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sergio Rivas
+
+MIT License
+
+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,99 @@
+# RandomVariateGenerator
+
+Is a random number generator for random variate occurs.
+
+You can generate random values from following distributions:
+
+    * Bernoulli
+    * Geometric
+    * Binomial
+    * Negative Binomial
+    * Exponential
+    * Poisson
+    * Triangular
+    * Normal
+    * Empirical
+    * Uniform (Discrete and Continuos)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'random_variate_generator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install random_variate_generator
+
+## Usage
+
+Add this in order to require funtionalities:
+
+    `gem 'random_variate_generator'`
+
+You have two ways of generate random numbers.
+
+### Simple way (Examples)
+
+  * `RandomVariateGenerator::Random.exponential(lambda: 0.5)`
+  * `RandomVariateGenerator::Random.normal(mu: 0.5, sigma: 3)`
+  * `RandomVariateGenerator::Random.uniform(min: 0.5, max: 2)`
+  * `RandomVariateGenerator::Random.triangular(min: 0.5, mode: 1, max: 2)`
+  * `RandomVariateGenerator::Random.uniform_discrete(min: 0, max: 20)`
+  * `RandomVariateGenerator::Random.bernoulli(probability_of_success: 0.2)`
+  * `RandomVariateGenerator::Random.binomial(probability_of_success: 0.2, number_of_trials: 3)`
+  * `RandomVariateGenerator::Random.negative_binomial(probability_of_success: 0.2, number_of_success: 2)`
+  * `RandomVariateGenerator::Random.geometric(probability_of_success: 0.2)`
+  * `RandomVariateGenerator::Random.poisson(lambda: 3)`
+  * `RandomVariateGenerator::Random.empirical(probabilities: [0.1, 0.3, 0.6])`
+
+### Formal way (Examples)
+
+With the formal way, you have to declare the random variate and then generate
+the value with the method `generate_value`
+
+```ruby
+require 'random_variate_generator'
+
+exp = RandomVariateGenerator::ExponentialVariate.new(lambda: 3)
+exp2 = RandomVariateGenerator::RandomVariate.create("exponential", lambda: 3)
+nor = RandomVariateGenerator::RandomVariate.create("normal", mu: -10, sigma: 2)
+unif = RandomVariateGenerator::UniformVariate.new(min: -3, max: 10)
+tri = RandomVariateGenerator::TriangularVariate.new(min: 1, mode: 10, max: 15)
+bin = RandomVariateGenerator::BinomialVariate.new(probability_of_success: 0.3, number_of_trials: 5)
+bin_neg =  RandomVariateGenerator::NegativeBinomialVariate.new(probability_of_success: 0.3, number_of_success: 2
+bern = RandomVariateGenerator::BernoulliVariate.new (probability_of_success: 0.3)
+poi =  RandomVariateGenerator::PoissonVariate.new(lambda: 3)
+empirical = RandomVariateGenerator::EmpiricalVariate.new(probabilities: [0.1, 0.3, 0.6])
+geo =  RandomVariateGenerator::GeometricVariate.new(probability_of_success: 0.3)
+
+open("generated_values.txt","w"){|f|
+  20000.times{
+    vals = [
+      exp.generate_value,
+      exp2.generate_value,
+      nor.generate_value,
+      unif.generate_value,
+      tri.generate_value,
+      bin.generate_value,
+      bin_neg.generate_value,
+      bern.generate_value,
+      poi.generate_value,
+      empirical.generate_value,
+      geo.generate_value]  
+    f.puts vals.collect{|x| x.to_s}.join ", "
+  }  
+}      
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/random_variate_generator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/random_variate_generator.rb

@@ -0,0 +1,20 @@
+require "random_variate_generator/version"
+
+module RandomVariateGenerator
+end
+
+require "random_variate_generator/invalid_parameter_exception"
+require "random_variate_generator/abstract_class_exception"
+require "random_variate_generator/random"
+require "random_variate_generator/random_variate"
+require "random_variate_generator/exponential_variate"
+require "random_variate_generator/uniform_variate"
+require "random_variate_generator/triangular_variate"
+require "random_variate_generator/normal_variate"
+require "random_variate_generator/bernoulli_variate"
+require "random_variate_generator/binomial_variate"
+require "random_variate_generator/negative_binomial_variate"
+require "random_variate_generator/geometric_variate"
+require "random_variate_generator/poisson_variate"
+require "random_variate_generator/empirical_variate"
+

data/lib/random_variate_generator/abstract_class_exception.rb

@@ -0,0 +1,9 @@
+module RandomVariateGenerator
+
+  class AbstractClassException < Exception  
+    def initialize
+      super "This is a abstract class, this method must be implemented in a subclass"
+    end
+  end
+
+end

data/lib/random_variate_generator/bernoulli_variate.rb

@@ -0,0 +1,18 @@
+module RandomVariateGenerator
+
+  class BernoulliVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:probability_of_success]
+         @probability_of_success = params[:probability_of_success] 
+       else
+         raise InvalidParameterException.new "Parameter :probability_of_success no specified"
+       end
+       raise InvalidParameterException.new "Parameter :probability_of_success must be greater than 0" if @probability_of_success <= 0
+    end       
+    
+    def generate_value
+      Random.bernoulli(:probability_of_success => @probability_of_success)
+    end
+  end
+
+end

data/lib/random_variate_generator/binomial_variate.rb

@@ -0,0 +1,25 @@
+module RandomVariateGenerator
+
+  class BinomialVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:probability_of_success]
+         @probability_of_success = params[:probability_of_success] 
+       else
+         raise InvalidParameterException.new "Parameter :probability_of_success no specified"
+       end
+       raise InvalidParameterException.new "Parameter :probability_of_success must be greater than 0" if @probability_of_success <= 0
+       if params[:number_of_trials]
+         @number_of_trials = params[:number_of_trials] 
+       else
+         raise InvalidParameterException.new "Parameter :number_of_trials no specified"
+       end
+       raise InvalidParameterException.new "Parameter :number_of_trials must be greater than 0" if @number_of_trials <= 0
+    end       
+    
+    def generate_value
+      Random.binomial(:probability_of_success => @probability_of_success,
+                                :number_of_trials => @number_of_trials)
+    end
+  end
+
+end

data/lib/random_variate_generator/empirical_variate.rb

@@ -0,0 +1,17 @@
+module RandomVariateGenerator
+
+  class EmpiricalVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:probabilities]
+         @probabilities = params[:probabilities] 
+       else
+         raise InvalidParameterException.new "Parameter :probabilities no specified"
+       end
+    end       
+    
+    def generate_value
+      Random.empirical(:probabilities => @probabilities)
+    end
+  end
+  
+end

data/lib/random_variate_generator/exponential_variate.rb

@@ -0,0 +1,18 @@
+module RandomVariateGenerator
+
+  class ExponentialVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:lambda]
+         @lambda = params[:lambda] 
+       else
+         raise InvalidParameterException.new "Parameter :lambda no specified"
+       end
+       raise InvalidParameterException.new "Parameter :lambda must be greater than 0" if @lambda <= 0
+    end       
+    
+    def generate_value
+      Random.exponential(:lambda => @lambda)
+    end
+  end
+  
+end

data/lib/random_variate_generator/geometric_variate.rb

@@ -0,0 +1,18 @@
+module RandomVariateGenerator
+
+  class GeometricVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:probability_of_success]
+         @probability_of_success = params[:probability_of_success] 
+       else
+         raise InvalidParameterException.new "Parameter :probability_of_success no specified"
+       end
+       raise InvalidParameterException.new "Parameter :probability_of_success must be greater than 0" if @probability_of_success <= 0
+    end       
+    
+    def generate_value
+      Random.geometric(:probability_of_success => @probability_of_success)
+    end
+  end
+
+end

data/lib/random_variate_generator/invalid_parameter_exception.rb

@@ -0,0 +1,7 @@
+module RandomVariateGenerator
+
+  class InvalidParameterException < Exception 
+  end
+
+end
+

data/lib/random_variate_generator/negative_binomial_variate.rb

@@ -0,0 +1,26 @@
+module RandomVariateGenerator
+
+  class NegativeBinomialVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:probability_of_success]
+         @probability_of_success = params[:probability_of_success] 
+       else
+         raise InvalidParameterException.new "Parameter :probability_of_success no specified"
+       end
+       raise InvalidParameterException.new "Parameter :probability_of_success must be greater than 0" if @probability_of_success <= 0
+       if params[:number_of_success]
+         @number_of_success = params[:number_of_success] 
+       else
+         raise InvalidParameterException.new "Parameter :number_of_success no specified"
+       end
+       raise InvalidParameterException.new "Parameter :number_of_success must be greater than 0" if @number_of_success <= 0
+    end       
+    
+    def generate_value
+      Random.negative_binomial(
+        :probability_of_success => @probability_of_success,
+        :number_of_success => @number_of_success)
+    end
+  end
+  
+end

data/lib/random_variate_generator/normal_variate.rb

@@ -0,0 +1,19 @@
+module RandomVariateGenerator
+
+  class NormalVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:mu] && params[:sigma]
+         @mu = params[:mu] 
+         @sigma = params[:sigma]
+       else
+         raise InvalidParameterException.new  "Parameter :mu or :sigma no specified"
+       end
+       raise InvalidParameterException.new "Parameter :sigma must be greater than 0" if @sigma <= 0
+    end       
+
+    def generate_value
+      Random.normal(:mu => @mu, :sigma => @sigma)
+    end
+  end
+  
+end

data/lib/random_variate_generator/poisson_variate.rb

@@ -0,0 +1,18 @@
+module RandomVariateGenerator
+
+  class PoissonVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:lambda]
+         @lambda = params[:lambda] 
+       else
+         raise InvalidParameterException.new "Parameter :lambda no specified"
+       end
+       raise InvalidParameterException.new "Parameter :lambda must be greater than 0" if @lambda <= 0
+    end       
+    
+    def generate_value
+      Random.poisson(:lambda => @lambda)
+    end
+  end
+
+end

data/lib/random_variate_generator/random.rb

@@ -0,0 +1,97 @@
+module RandomVariateGenerator
+
+  class Random 
+  
+    def self.exponential(params)    
+      u = rand()
+      u = rand() while u <= 1e-7
+      -Math.log(u)/params[:lambda]
+    end
+    
+    def self.normal(params)
+      x2pi = rand() * Math::PI
+      g2rad = Math.sqrt(-2.0 * Math.log(1.0 - rand()))
+      z = Math.cos(x2pi) * g2rad
+      params[:mu] + z*params[:sigma]
+    end
+
+    def self.uniform(params)
+      params[:min] + (params[:max]-params[:min]) * rand()
+    end
+    
+    def self.triangular(params)
+      params[:min] *= 1.0
+      params[:mode] *= 1.0
+      params[:max] *= 1.0
+      u = rand()
+      c = 0.5
+      (params[:mode] - params[:min]) / (params[:max] - params[:min]) if params[:mode]
+      if u > c
+        u = 1.0 - u
+        c = 1.0 - c
+        params[:min], params[:max] = params[:max], params[:min]
+      end
+      params[:min] + (params[:max] - params[:min]) * (u * c) ** 0.5
+    end
+    
+    def self.uniform_discrete(params)
+      uniform(:min => params[:min],
+              :max => (params[:max]+1)).to_i
+    end   
+      
+    def self.bernoulli(params)
+      (rand() < params[:probability_of_success])? 1 : 0
+    end
+    
+    def self.binomial(params)
+      counter = 0
+      params[:number_of_trials].times{ 
+        counter += bernoulli(:probability_of_success => params[:probability_of_success]) 
+      } 
+      counter
+    end
+
+    def self.negative_binomial(params)
+      counter = 0
+      success_counter = 0
+      while success_counter < params[:number_of_success]
+        counter += 1
+        success_counter += bernoulli(:probability_of_success => params[:probability_of_success])
+      end           
+      counter
+    end
+    def self.geometric(params) 
+      negative_binomial(:number_of_success => 1,
+                        :probability_of_success => params[:probability_of_success])
+    end
+    
+    def self.poisson(params) 
+      cummulative_time = 0
+      cummulative_time += exponential(:lambda => params[:lambda])
+      counter = 0
+      while cummulative_time <= 1.0
+        counter += 1
+        cummulative_time += exponential(:lambda => params[:lambda])
+      end   
+      counter
+    end
+    
+    def self.empirical(params) 
+      probs = params[:probabilities]
+      cda = []
+      acum = 0
+      probs.each{|x|
+        acum += x
+        cda << acum
+      }
+      cda << 1 
+      cda.each{|x| x=1 if x > 1}
+      u = rand
+      index = 0
+      index += 1 while u > cda[index]
+      index
+    end
+    
+  end
+
+end

data/lib/random_variate_generator/random_variate.rb

@@ -0,0 +1,38 @@
+module RandomVariateGenerator
+
+  class RandomVariate  
+    
+    def self.create(distribution_name, args = {})
+      if distribution_name.to_s == "exponential"
+        return ExponentialVariate.new args
+      elsif distribution_name.to_s == "normal"
+        return NormalVariate.new args
+      elsif distribution_name.to_s == "uniform"
+        return UniformVariate.new args
+      elsif distribution_name.to_s == "triangular"
+        return TriangularVariate.new args
+      elsif distribution_name.to_s == "binomial"
+        return BinomialVariate.new args
+      elsif distribution_name.to_s == "geometric"
+        return GeometricVariate.new args
+      elsif distribution_name.to_s == "negative_binomial"
+        return NegativeBinomialVariate.new args
+      elsif distribution_name.to_s == "bernoulli"
+        return BernoulliVariate.new args
+      elsif distribution_name.to_s == "poisson"
+        return PoissonVariate.new args
+      elsif distribution_name.to_s == "empirical"
+        return EmpiricalVariate.new args
+      end                               
+      raise InvalidParameterException.new  "Unknowed distribution"
+    end
+    
+    def generate_value
+      raise AbstractClassException
+    end
+    
+    #private_class_method :new
+    
+  end
+
+end

data/lib/random_variate_generator/triangular_variate.rb

@@ -0,0 +1,22 @@
+module RandomVariateGenerator
+
+  class TriangularVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:min] && params[:mode] && params[:max]
+         @min = params[:min] 
+         @mode = params[:mode]
+         @max = params[:max]   
+       else
+         raise InvalidParameterException.new "Parameter :min, :mode or :max no specified"
+       end 
+       raise InvalidParameterException.new "Parameter :max must be greater than :mode" if @mode >= @max
+       raise InvalidParameterException.new "Parameter :max must be greater than :min" if @min >= @max
+       raise InvalidParameterException.new "Parameter :mode must be greater than :min" if @min >= @mode             
+    end       
+    
+    def generate_value
+      Random.triangular(:min => @min, :mode => @mode, :max => @max)
+    end
+  end
+
+end

data/lib/random_variate_generator/uniform_variate.rb

@@ -0,0 +1,19 @@
+module RandomVariateGenerator
+
+  class UniformVariate <  RandomVariate
+    def initialize(params = {})
+       if params[:min] && params[:max]
+         @min = params[:min] 
+         @max = params[:max]
+       else
+         raise InvalidParameterException.new "Parameter :min or :max no specified"
+       end
+       raise InvalidParameterException.new "Parameter :max must be greater than :min" if @min >= @max
+    end       
+    
+    def generate_value
+      Random.uniform(:min => @min,:max => @max)
+    end
+  end
+
+end

data/lib/random_variate_generator/version.rb

@@ -0,0 +1,3 @@
+module RandomVariateGenerator
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: random_variate_generator
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Sergio Rivas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Random value generator of several distributions
+email:
+- sergiorivas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/random_variate_generator.rb
+- lib/random_variate_generator/abstract_class_exception.rb
+- lib/random_variate_generator/bernoulli_variate.rb
+- lib/random_variate_generator/binomial_variate.rb
+- lib/random_variate_generator/empirical_variate.rb
+- lib/random_variate_generator/exponential_variate.rb
+- lib/random_variate_generator/geometric_variate.rb
+- lib/random_variate_generator/invalid_parameter_exception.rb
+- lib/random_variate_generator/negative_binomial_variate.rb
+- lib/random_variate_generator/normal_variate.rb
+- lib/random_variate_generator/poisson_variate.rb
+- lib/random_variate_generator/random.rb
+- lib/random_variate_generator/random_variate.rb
+- lib/random_variate_generator/triangular_variate.rb
+- lib/random_variate_generator/uniform_variate.rb
+- lib/random_variate_generator/version.rb
+homepage: ''
+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.2.1
+signing_key: 
+specification_version: 4
+summary: Random Variate Generator for Ruby
+test_files: []