croupier 1.6.0 → 2.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf6d755404722c636a61587f2381ca5ff96ff62b
+  data.tar.gz: 2229632adcaab36de7a98fd4d1d6bca922485a6d
+SHA512:
+  metadata.gz: c03a5dcb2b26a88b3d6ccfb0bc205b72576ed9d4e802a10823ffca194ee291b8bbbe650870ba6a522e1c473fdee4216e64a1e6e7b78118366fa9f7182bd0a12f
+  data.tar.gz: 463e5689dc2fe99f689706925acfa1951689369617b9c4b58598f025e9e222661f79fd13f74976a3e3fff4c51b25053b767633703ca2c627e4639c00528fbab4

data/README.md

@@ -3,7 +3,7 @@
 Croupier generates random samples of numbers with specific probability distributions.
 
 [![Gem Version](https://badge.fury.io/rb/croupier.png)](http://badge.fury.io/rb/croupier)
-[![Build Status](https://secure.travis-ci.org/xuanxu/croupier.png?branch=master)](http://travis-ci.org/xuanxu/croupier)
+[![Build Status](https://secure.travis-ci.org/croupiers/croupier-rb.png?branch=2.0)](http://travis-ci.org/croupiers/croupier-rb)
 
 ## Install
 
@@ -84,7 +84,7 @@ To get a list of all available distributions/methods in Distributions module cal
 
     Croupier::Distributions.list
 
-Since 1.6.0, distributions have a ```to_enum``` method that return an (infinity) enumerator, so you
+Distributions have a ```to_enum``` method that return an (infinity) enumerator, so you
 can use any Enumerable method on it:
 
     dist = Croupier::Distributions.exponential(:lambda => 17).to_enum

data/Rakefile

@@ -7,3 +7,10 @@ Rake::TestTask.new do |t|
 end
 task :default => :test
 
+namespace :test do
+  task :distributions do
+    puts `./generate_test_data.sh`
+    puts `cd test && Rscript rtests.R`
+  end
+end
+

data/lib/croupier/distribution.rb

@@ -6,13 +6,107 @@ module Croupier
   #
   class Distribution
     attr_accessor :parameters
-    attr_reader :name, :description
+    attr_accessor :generator
+
+    class << self
+      # Sets the name property of the distribution.
+      # if given
+      #
+      # @param distribution_name [String,nil] the name of the distribution
+      # @return [String] current distribution name
+      def distribution_name distribution_name=nil
+        @distribution_name = distribution_name if distribution_name
+        @distribution_name
+      end
+
+      # Sets the description property of the distribution
+      # if given
+      #
+      # @param description [String,nil] description for the distribution
+      # @return [String] current description
+      def distribution_description description=nil
+        @distribution_description = description if description
+        @distribution_description
+      end
+
+      # Sets the generator class for this distribution, if given
+      #
+      # @param generator_class [Class] class for the generator for this distribution
+      # @return [Class] current generator class
+      def generator_class generator_class=nil
+        @generator_class = generator_class if generator_class
+        @generator_class
+      end
+
+      # Sets the generator block for this distribution, if given
+      #
+      # @param block [Proc] block for the generator
+      # @return [Proc] current generator block
+      def generator_block &block
+        @generator_block = block if block_given?
+        @generator_block
+      end
+
+      # Defines a hash with banner and all available CLI options.
+      # It is a hash with two keys:
+      #  :banner =>  A string used as banner in the command line help
+      #  :options => An array of arrays each one representing a CLI option
+      #             with the following format:[:option, 'description', {hash of option params}]
+      #   Example:
+      #   {:banner => "This distribution generates only number 33",
+      #    :options => [
+      #      [:mean, 'The mean of the distribution', {:default => 33}],
+      #      [:median, 'Median of the distribution',{:default => 33.0, :type => :float}]
+      #    ]
+      #   }
+      # @param options [Hash] new cli options
+      # return [Hash] current cli options
+      def cli_options options=nil
+        @cli_options = options if options
+        @cli_options || {}
+      end
+
+      # Sets the cli_name if given
+      #
+      # @param cli_name [String] new cli name
+      # @return [String] current cli name
+      def cli_name cli_name=nil
+        @cli_name = cli_name if cli_name
+        @cli_name
+      end
+
+      def default_parameters
+        Hash[(cli_options[:options]||{}).map do |name, desc, hash|
+          [name,hash[:default]]
+        end]
+      end
+
+      def method_missing(method, *args, &block) # :nodoc:
+        return super unless self.respond_to?(method)
+        generator = ::Croupier::DistributionGenerators.all.find{|d| d.method_name == method.to_s}
+        self.generator_class generator
+        self.generator_block &block
+      end
+
+      def respond_to?(method, include_private = false) # :nodoc:
+        ::Croupier::DistributionGenerators.list.include?(method.to_s) || super(method, include_private)
+      end
+    end
 
     # Initializes Distribution object and adds received options to the distribution parameters.
     def initialize(options={})
-      @name = nil
-      @description = nil
       configure(options)
+      create_generator
+    end
+
+    # Alias for `self.class.distribution_name`
+    # @return [String] distribution name
+    def name
+      self.class.distribution_name
+    end
+
+    def description
+      self.class.distribution_description
     end
 
     # Merge the hash of options into the default distribution parameters
@@ -22,25 +116,17 @@ module Croupier
 
     # Default hash of distribution parameters
     def default_parameters
-      {}
+      self.class.default_parameters
     end
 
     # Main method to generate n random numbers using the current probability distribution
     def generate_sample(n=1)
-      if self.respond_to? :inv_cdf
-        (1..n).map{ inv_cdf(rand) }
-      else
-        (1..n).map{ generate_number }
-      end
+      self.to_enum.take(n).to_a
     end
 
     # Generates one random number using the current probability distribution
     def generate_number
-      if self.respond_to? :inv_cdf
-        inv_cdf(rand)
-      else
-        generate_sample(1).first
-      end
+      self.to_enum.next
     end
 
     # convenience method for lazy programmers
@@ -48,32 +134,25 @@ module Croupier
       @parameters
     end
 
-    # Defines a hash with banner and all available CLI options.
-    # It is a hash with two keys:
-    #  :banner =>  A string used as banner in the command line help
-    #  :options => An array of arrays each one representing a CLI option
-    #             with the following format:[:option, 'description', {hash of option params}]
-    #   Example:
-    #   {:banner => "This distribution generates only number 33",
-    #    :options => [
-    #      [:mean, 'The mean of the distribution', {:default => 33}],
-    #      [:median, 'Median of the distribution',{:default => 33.0, :type => :float}]
-    #    ]
-    #   }
-    def self.cli_options
-      {:banner => nil, :options=>[]}
-    end
+    # Make Croupier::Distribution an Enumerable
+    include Enumerable
 
-    # Defines the name of this Distribution to be used from the CLI.
-    def self.cli_name
-      ''
+    def each &block
+      if block_given?
+        self.to_enum.each &block
+      else
+        self.to_enum.each
+      end
     end
 
     def to_enum
-      Enumerator.new do |y|
-        loop do
-          y << generate_number
-        end
+      @enum ||= @generator.to_enum.lazy
+    end
+
+    protected
+    def create_generator
+      if self.class.generator_class && self.class.generator_block
+        @generator = self.class.generator_class.new self, &self.class.generator_block
       end
     end
   end

data/lib/croupier/distribution_generator.rb

@@ -0,0 +1,57 @@
+module Croupier
+
+  class DistributionGenerator
+
+    class << self
+
+      # Gets and optionally sets the method name for this generator
+      #
+      # @param new_method_name [String] new method name
+      # @return [String] current method name
+      def method_name new_method_name=nil
+        @method_name = new_method_name if new_method_name
+        @method_name
+      end
+    end
+
+    attr_reader :distribution
+    attr_reader :block
+
+    def initialize distribution, &block
+      @distribution = distribution
+      @block = block
+    end
+
+
+    # Accessor to distribution parameters
+    #
+    # @return [Hash<String,Object>] distribution parameters
+    def params
+      self.distribution.params
+    end
+
+    def croupier
+      ::Croupier::Distributions
+    end
+
+    # @abstract Given some parameters, returns the minimum sample
+    # it can generate. Some generators generate more
+    # than one number each iteration.
+    #
+    # @return [Array<Numeric>] sample
+    def generate_minimum_sample
+
+    end
+
+    def to_enum
+      Enumerator.new do |y|
+        loop do
+          sample = self.generate_minimum_sample
+          sample.each do |s|
+            y << s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/croupier/distribution_generators/enumerator_block_generator.rb

@@ -0,0 +1,23 @@
+module Croupier
+
+  module DistributionGenerators
+
+    # Call `enumerator_block` with a block
+    # that will be called as the parameter for
+    # Enumerator.new
+    class EnumeratorBlockGenerator < ::Croupier::DistributionGenerator
+
+      method_name "enumerator_block"
+
+      def initilize distribution, &block
+        super distribution, &block
+      end
+
+      def to_enum
+        Enumerator.new do |y|
+          self.distribution.instance_exec(y,&self.block)
+        end.lazy
+      end
+    end
+  end
+end

data/lib/croupier/distribution_generators/enumerator_generator.rb

@@ -0,0 +1,21 @@
+module Croupier
+
+  module DistributionGenerators
+
+    # Call `enumerator` with a block
+    # that returns an enumerator.
+    # First block argument is the Croupier::Distributions module
+    class EnumeratorGenerator < ::Croupier::DistributionGenerator
+
+      method_name "enumerator"
+
+      def initilize distribution, &block
+        super distribution, &block
+      end
+
+      def to_enum
+        self.distribution.instance_exec(::Croupier::Distributions, &self.block).lazy
+      end
+    end
+  end
+end

data/lib/croupier/distribution_generators/inverse_cdf_generator.rb

@@ -0,0 +1,21 @@
+module Croupier
+
+  module DistributionGenerators
+
+    class InverseCDFGenerator < ::Croupier::DistributionGenerator
+
+      method_name "inv_cdf"
+
+      def initilize distribution, &block
+        super distribution, &block
+      end
+
+      def to_enum
+        # Fix when final api is availble
+        croupier.uniform.to_enum.lazy.map do |n|
+          distribution.instance_exec(n, &self.block)
+        end
+      end
+    end
+  end
+end

data/lib/croupier/distribution_generators/minimum_sample_generator.rb

@@ -0,0 +1,24 @@
+module Croupier
+
+  module DistributionGenerators
+
+    class MinimumSampleGenerator < ::Croupier::DistributionGenerator
+
+      method_name "minimum_sample"
+
+      def initilize distribution, &block
+        super distribution, &block
+      end
+
+      def to_enum
+        Enumerator.new do |y|
+          loop do
+            distribution.instance_exec(&self.block).each do |a|
+              y << a
+            end
+          end
+        end.lazy
+      end
+    end
+  end
+end

data/lib/croupier/distribution_generators.rb

@@ -0,0 +1,18 @@
+module Croupier
+  module DistributionGenerators
+    class << self
+      # An array containing all available Distribution classes
+      def all
+        ::Croupier::DistributionGenerators.constants(false).each_with_object([]){|distrib,list|
+          d = ::Croupier::DistributionGenerators.const_get(distrib)
+          list << d if (d.is_a?(Class) && d.superclass == Croupier::DistributionGenerator)
+        }.uniq.compact
+      end
+
+      # list of all available distribution names (and methods on Distributions module)
+      def list
+        self.all.map(&:method_name).sort
+      end
+    end
+  end
+end

data/lib/croupier/distributions/bernoulli.rb

@@ -8,37 +8,30 @@ module Croupier
     # Equivalent to a Binomial(1,p)
     class Bernoulli < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Bernoulli distribution"
-        @description = "Discrete probability distribution taking value 1 with success probability p and value 0 with failure probability 1-p."
-        configure(options)
-        raise Croupier::InputParamsError, "Probability of success must be in the interval [0,1]" if params[:success] > 1 || params[:success] < 0
-      end
+      distribution_name "Bernoulli distribution"
+      distribution_description "Discrete probability distribution taking value 1 with success probability p and value 0 with failure probability 1-p."
 
-      def generate_number
-        binomial_1_p.generate_number
-      end
+      cli_name "bernoulli"
 
-      def default_parameters
-        {:success => 0.5}
-      end
+      cli_options({
+        options: [
+          [:success, 'success probability', {type: :float, short: "-p", default: 0.5}]
+        ],
+        banner: "Bernoulli distribution. Discrete probability distribution taking value 1 with success probability p and value 0 with failure probability 1-p."
+      })
 
-      def self.cli_name
-        "bernoulli"
+      enumerator do |c|
+        c.binomial(success: success, size: 1).to_enum.lazy
       end
 
-      def self.cli_options
-        {:options => [
-           [:success, 'success probability', {:type=>:float, :short => "-p", :default => 0.5}]
-         ],
-         :banner => "Bernoulli distribution. Discrete probability distribution taking value 1 with success probability p and value 0 with failure probability 1-p."
-        }
+      def initialize(options={})
+        super(options)
+        raise Croupier::InputParamsError, "Probability of success must be in the interval [0,1]" if params[:success] > 1 || params[:success] < 0
       end
-      
-      private
-      def binomial_1_p
-        @binomial_1_p ||= ::Croupier::Distributions::Binomial.new(:success => params[:success], :size => 1)
+
+      def success
+        params[:success]
       end
     end
   end
-end
+end

data/lib/croupier/distributions/binomial.rb

@@ -8,44 +8,45 @@ module Croupier
     # probability p
     class Binomial < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Binomial distribution"
-        @description = "Discrete probability distribution of the number of successes in a sequence of Bernoulli trials."
-        configure(options)
-        raise Croupier::InputParamsError, "Probability of success must be in the interval [0,1]" if params[:success] > 1 || params[:success] < 0
-      end
+      distribution_name "Binomial distribution"
+
+      distribution_description "Discrete probability distribution of the number of successes in a sequence of Bernoulli trials."
+
+      cli_name "binomial"
+
+      cli_options({
+        options: [
+          [:size, 'number of trials', {type: :integer, default: 1}],
+          [:success, 'success probability of each trial', {type: :float, short: "-p", default: 0.5}]
+        ],
+        banner: "Binomial distribution. Discrete probability distribution of the number of successes in a sequence of Bernoulli trials."
+      })
 
-      def generate_number
-        x = -1
-        s = 0
+      enumerator_block do |y|
+        g = ::Croupier::Distributions.geometric(success: success).to_enum.lazy
         loop do
-          s += base_geometric.generate_number
-          x += 1
-          break if s > params[:size]
-        end
-        x
-      end
+          x = -1; s = 0
+
+          begin
+            s += g.next
+            x += 1
+          end while s <= size
 
-      def default_parameters
-        {:success => 0.5, :size => 1}
+          y << x
+        end
       end
 
-      def self.cli_name
-        "binomial"
+      def initialize(options={})
+        super(options)
+        raise Croupier::InputParamsError, "Probability of success must be in the interval [0,1]" if params[:success] > 1 || params[:success] < 0
       end
 
-      def self.cli_options
-        {:options => [
-           [:size, 'number of trials', {:type => :integer, :default => 1}],
-           [:success, 'success probability of each trial', {:type=>:float, :short => "-p", :default => 0.5}]
-         ],
-         :banner => "Binomial distribution. Discrete probability distribution of the number of successes in a sequence of Bernoulli trials."
-        }
+      def size
+        params[:size]
       end
 
-      private
-      def base_geometric
-        @base_geometric ||= ::Croupier::Distributions::Geometric.new(success: params[:success])
+      def success
+        params[:success]
       end
 
     end

data/lib/croupier/distributions/cauchy.rb

@@ -7,32 +7,35 @@ module Croupier
     #
     class Cauchy < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Cauchy distribution"
-        @description = "Continuous probability distribution describing resonance behavior"
-        configure(options)
-        raise Croupier::InputParamsError, "Invalid scale value, it must be positive" unless params[:scale] > 0
-      end
+      distribution_name "Cauchy distribution"
+
+      distribution_description "Continuous probability distribution describing resonance behavior"
 
-      def inv_cdf n
-        params[:location] + (params[:scale] * Math.tan(Math::PI * (0.5 - n)))
+      cli_name "cauchy"
+
+      cli_options({
+        options: [
+          [:location, 'location param', {type: :float, default:0.0}],
+          [:scale, 'scale param', {type: :float, default: 1.0}],
+        ],
+        banner: "Cauchy continuous distribution. Generate numbers following a Cauchy distribution with location and scale parameters"
+      })
+
+      inv_cdf do |n|
+        location + (scale * Math.tan( Math::PI * (0.5 - n)))
       end
 
-      def default_parameters
-        {:location => 0.0, :scale => 1.0}
+      def initialize(options={})
+        super(options)
+        raise Croupier::InputParamsError, "Invalid scale value, it must be positive" unless params[:scale] > 0
       end
 
-      def self.cli_name
-        "cauchy"
+      def location
+        params[:location]
       end
 
-      def self.cli_options
-        {:options => [
-           [:location, 'location param', {:type=>:float, :default => 0.0}],
-           [:scale, 'scale param', {:type=>:float, :default => 1.0}],
-         ],
-         :banner => "Cauchy continuous distribution. Generate numbers following a Cauchy distribution with location and scale parameters"
-        }
+      def scale
+        params[:scale]
       end
     end
   end

data/lib/croupier/distributions/credit_card.rb

@@ -7,10 +7,46 @@ module Croupier
     #
     class CreditCard < ::Croupier::Distribution
 
+      distribution_name "CreditCard distribution"
+
+      distribution_description "Generates random credit card numbers."
+
+      cli_name "credit_card"
+
+      cli_options({
+        options: [
+          [:master_card, 'master card type', {type: :boolean, default: false}],
+          [:american_express, 'american express card type', {type: :boolean, default: false}],
+          [:visa, 'visa card type', {type: :boolean, default: false}],
+          [:discover, 'discover card type', {type: :boolean, default: false}],
+          [:initial_values, 'initial values for the credit card. They will be place after card type if one is given.', {type: :string, default: ""}]
+        ],
+        banner: "Credit Card distribution. Generate random card numbers"
+      })
+
+      # Returns a lambda that completes
+      # the credit card number up to
+      # 15 numbers.
+      def fill_number
+        ->(n) { "#{n}#{generate_random_string(15-n.size)}"[0..14] }
+      end
+
+      # Returns a lambda that adds
+      # the checksum number
+      def add_checksum
+        ->(n) { "#{n}#{check_digit_for(n)}" }
+      end
+
+      enumerator do |c|
+        c.degenerate(constant: init).to_enum.lazy.map(&fill_number).map(&add_checksum)
+      end
+
       def initialize(options={})
-        @name = "CreditCard distribution"
-        @description = "Generates random credit card numbers."
-        configure(options)
+        super(options)
+      end
+
+      def init
+        "#{initial_value_by_card_type}#{initial_values}"
       end
 
       def generate_number
@@ -20,20 +56,6 @@ module Croupier
         n + check_digit_for(n).to_s
       end
 
-      def default_parameters
-        {
-          :master_card => false,
-          :american_express => false,
-          :discover => false,
-          :visa => false,
-          :initial_values => ""
-        }
-      end
-
-      def self.cli_name
-        "credit_card"
-      end
-
       def check_digit_for(n)
         # Sum, every odd number should be doubled.
         # If result has two digits, they should be summed up.
@@ -68,18 +90,6 @@ module Croupier
         return 6 if params[:discover]
         ""
       end
-
-      def self.cli_options
-        {:options => [
-           [:master_card, 'master card type', {:type=>:boolean, :default => false}],
-           [:american_express, 'american express card type', {:type=>:boolean, :default => false}],
-           [:visa, 'visa card type', {:type=>:boolean, :default => false}],
-           [:discover, 'discover card type', {:type=>:boolean, :default => false}],
-           [:initial_values, 'initial values for the credit card. They will be place after card type if one is given.', {:type=>:string, :default => ""}]
-         ],
-         :banner => "Credit Card distribution. Generate random card numbers"
-        }
-      end
     end
   end
 end