croupier 1.6.0 → 2.0.0.rc1

data/lib/croupier/distributions/degenerate.rb

@@ -6,30 +6,27 @@ module Croupier
     # Discrete probability distribution that returns the same value.
     class Degenerate < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Degenerate distribution"
-        @description = "Discrete probability distribution that returns the same value each time."
-        configure(options)
-      end
+      distribution_name "Degenerate distribution"
 
-      def generate_number
-        params[:constant]
-      end
+      distribution_description "Discrete probability distribution that returns the same value each time."
 
-      def default_parameters
-        {:constant => 42.0}
-      end
+      cli_name "degenerate"
+
+      cli_options({
+        options: [
+          [:constant, 'value to be returned', {type: :float, default: 42.0}]
+        ],
+        banner: "Degenerate distribution. Discrete probability distribution that returns the same value each time."
+       })
 
-      def self.cli_name
-        "degenerate"
+      enumerator_block do |y|
+        loop do
+          y << params[:constant]
+        end
       end
 
-      def self.cli_options
-        {:options => [
-           [:constant, 'value to be returned', {:type=>:float, :default => 42.0}]
-         ],
-         :banner => "Degenerate distribution. Discrete probability distribution that returns the same value each time."
-        }
+      def initialize(options={})
+        super(options)
       end
     end
   end

data/lib/croupier/distributions/exponential.rb

@@ -8,31 +8,30 @@ module Croupier
     #
     class Exponential < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Exponential distribution"
-        @description = "Continuous probability distribution with a lambda param rate describing the time between events in a Poisson process"
-        configure(options)
-        raise Croupier::InputParamsError, "Invalid interval values" if params[:lambda] <= 0
-      end
+      distribution_name "Exponential distribution"
 
-      def inv_cdf n
-        (-1/params[:lambda]) * Math.log(n)
-      end
+      distribution_description "Continuous probability distribution with a lambda param rate describing the time between events in a Poisson process"
 
-      def default_parameters
-        {:lambda => 1.0}
+      cli_name "exponential"
+
+      cli_options({
+        options: [
+          [:lambda, 'rate param', {type: :float, default: 1.0}]
+        ],
+        banner: "Exponential distribution. Generate numbers following a exponential distribution for a given lambda rate"
+      })
+
+      inv_cdf do |n|
+        (-1 / lambda) * Math.log(1 - n)
       end
 
-      def self.cli_name
-        "exponential"
+      def initialize(options={})
+        super(options)
+        raise Croupier::InputParamsError, "lambda cannot be negative" if params[:lambda] <= 0
       end
 
-      def self.cli_options
-        {:options => [
-           [:lambda, 'rate param', {:type=>:float, :default => 1.0}]
-         ],
-         :banner => "Exponential distribution. Generate numbers following a exponential distribution for a given lambda rate"
-        }
+      def lambda
+        params[:lambda]
       end
     end
   end

data/lib/croupier/distributions/gamma.rb

@@ -7,58 +7,87 @@ module Croupier
     # (defaults to 1) and scale (defaults to 1).
     class Gamma < ::Croupier::Distribution
 
+      distribution_name "Gamma distribution"
+
+      distribution_description "Family of continuous distributions with two parameters, shape and scale"
+
+      cli_name "gamma"
+
+      cli_options({
+        options: [
+          [:shape, 'shape of the distribution', {type: :float, default: 1.0}],
+          [:scale, 'scale of the distribution', {type: :float, default: 1.0}]
+        ],
+        banner: "Family of continuous distributions with two parameters, shape and scale."
+      })
+
+      enumerator do |c|
+        c.degenerate(constant: scale).to_enum.lazy.zip(xi_enum, adjust_enum).map do |s,x,a|
+          s * (x - a)
+        end
+      end
+
       def initialize(options={})
-        @name = "Gamma distribution"
-        @description = "Family of continuous distributions with two parameters, shape and scale"
-        configure(options)
+        super(options)
       end
 
-      def generate_number
-        params[:scale] * (gen_xi - (1..params[:shape].floor).map { Math.log(1 - rand) }.inject(&:+) )
+      def shape
+        params[:shape]
       end
 
-      def default_parameters
-        {:shape => 1.0, :std => 1.0}
+      def scale
+        params[:scale]
       end
 
-      def self.cli_name
-        "gamma"
+      def delta
+        @delta ||= shape - shape.floor
       end
 
-      def self.cli_options
-        {:options => [
-           [:shape, 'shape of the distribution', {:type=>:float, :default => 1.0}],
-           [:scale, 'scale of the distribution', {:type=>:float, :default => 1.0}]
-         ],
-         :banner => "Family of continuous distributions with two parameters, shape and scale."
-        }
+      def v_0
+        @v_0 ||= Math::E / (delta + Math::E)
       end
 
       protected
+
+      def adjust_enum
+        uniform.map{|n| Math.log(n) }.each_slice(shape.floor).map do |slice|
+          slice.inject &:+
+        end
+      end
+
       # Based on Ahrens-Dieter acceptance-rejection method
       # as described on Wikipedia:
       # http://en.wikipedia.org/wiki/Gamma_distribution#Generating_gamma-distributed_random_variables
-      def gen_xi
-        delta = params[:shape] - params[:shape].floor
-        v_0 = Math::E / ( delta  + Math::E )
-        eta = 1; xi = 0;
-
-        begin
-          # Generate thre independent uniformly distributed
-          # on interval (0,1]random variables
-          v_1 = 1 - rand; v_2 = 1 - rand; v_3 = 1 - rand;
-
-          # Generate a new xi.
-          if v_1 < v_0
-            xi = (v_2 ** (1/delta))
-            eta = v_3 * (xi ** (delta - 1))
-          else
-            xi = 1 - Math.log(v_2)
-            eta = v_3 * (Math::E ** (-xi))
-          end
-        end while eta > (xi ** (delta - 1)) * (Math::E ** -xi)
-
-        xi
+
+      def xi_enum
+        uniform.zip(uniform, uniform).map do |v1, v2, v3|
+          x = xi v1, v2, v3
+          [x, eta(x, v1, v2, v3)]
+        end.reject do |x,e|
+          e > (x** (delta - 1)) * (Math.exp(-x))
+        end.map do |x,e|
+          x
+        end
+      end
+
+      def xi v1, v2, v3
+        if v1 < v_0
+          v2** (1/delta)
+        else
+          1 - Math.log(v2)
+        end
+      end
+
+      def eta xi, v1, v2, v3
+        if v1 < v_0
+          v3 * (xi** (delta - 1))
+        else
+          v3 * Math.exp(-xi)
+        end
+      end
+
+      def uniform
+        ::Croupier::Distributions.uniform(included: 1, excluded: 0).to_enum.lazy
       end
     end
   end

data/lib/croupier/distributions/geometric.rb

@@ -12,33 +12,32 @@ module Croupier
     # (The Art of Computer Programming, Volume 2, 3.4.1.F )
     class Geometric < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Geometric distribution"
-        @description = "Discrete probability distribution that expresses the number of X Bernoulli trials needed to get one success, supported on the set { 1, 2, 3, ...}"
-        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 "Geometric distribution"
+
+      distribution_description "Discrete probability distribution that expresses the number of X Bernoulli trials needed to get one success, supported on the set { 1, 2, 3, ...}"
+
+      cli_name "geometric"
+
+      cli_options({
+        options: [
+          [:success, 'success probability of each trial', {type: :float, short: "-p", default: 0.5}]
+        ],
+        banner: "Geometric distribution. Discrete probability distribution that expresses the number of X Bernoulli trials needed to get one success, supported on the set { 1, 2, 3, ...} }"
+      })
 
       # Fair point: it is not the inverse of the cdf,
       # but it generates the distribution from an uniform.
-      def inv_cdf n
-        (Math.log(1-n) / Math.log(1-params[:success])).ceil
-      end
-
-      def default_parameters
-        {:success => 0.5}
+      inv_cdf do |n|
+        (Math.log(1.0-n) / Math.log(1.0-success)).ceil
       end
 
-      def self.cli_name
-        "geometric"
+      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 => [
-           [:success, 'success probability of each trial', {:type=>:float, :short => "-p", :default => 0.5}]
-         ],
-         :banner => "Geometric distribution. Discrete probability distribution that expresses the number of X Bernoulli trials needed to get one success, supported on the set { 1, 2, 3, ...} }"
-        }
+      def success
+        params[:success]
       end
     end
   end

data/lib/croupier/distributions/nbinomial.rb

@@ -10,49 +10,38 @@ module Croupier
     # Wikipedia -- http://en.wikipedia.org/wiki/Negative_binomial_distribution
     class Nbinomial < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Negative binomial distribution"
-        @description = "Discrete probability distribution of the number of successes in a sequence of Bernoulli trials before a specified (non-random) number of failures (denoted size) occur."
-        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 "Negative binomial distribution"
 
-      # Fair point: it is not the inverse of the cdf,
-      # but it generates the distribution from an uniform.
-      def generate_sample n=1
-        generate_geometrics(n).each_slice(params[:size]).map do |sample|
-          sample.inject(-params[:size], &:+) # Inject starts on -size because
-          # this way it is equivalent to:
-          # sample.map{|x| x - 1}.inject(&:+)
-        end
-      end
+      distribution_description "Discrete probability distribution of the number of successes in a sequence of Bernoulli trials before a specified (non-random) number of failures (denoted size) occur."
 
-      def default_parameters
-        {:success => 0.5, :size => 1}
-      end
+      cli_name "nbinomial"
 
-      def self.cli_name
-        "nbinomial"
-      end
+      cli_options({
+        options: [
+          [:size, 'number of errors', {type: :integer, default: 1}],
+          [:success, 'success probability of each trial', {type: :float, short: "-p", default: 0.5}]
+        ],
+        banner: "Negative binomial distribution. Discrete probability distribution of the number of successes in a sequence of Bernoulli trials before a specified (non-random) number of failures (denoted size) occur."
+      })
 
-      def self.cli_options
-        {:options => [
-           [:size, 'number of errors', {:type => :integer, :default => 1}],
-           [:success, 'success probability of each trial', {:type=>:float, :short => "-p", :default => 0.5}]
-         ],
-         :banner => "Negative binomial distribution. Discrete probability distribution of the number of successes in a sequence of Bernoulli trials before a specified (non-random) number of failures (denoted size) occur."
-        }
+      enumerator do |c|
+        c.geometric(success: success).to_enum.lazy.each_slice(size).map do |x|
+          x.inject(-size,&:+)
+        end
       end
 
-      private
-      def base_geometric
-        ::Croupier::Distributions::Geometric.new(success: params[:success])
+      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 generate_geometrics(n)
-        base_geometric.generate_sample(params[:size]*n)
+      def success
+        params[:success]
       end
 
+      def size
+        params[:size]
+      end
     end
   end
 end

data/lib/croupier/distributions/normal.rb

@@ -8,48 +8,44 @@ module Croupier
     #
     class Normal < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Normal distribution"
-        @description = "Continuous distribution (mu,sigma) (defaults to (0,1) ) where mu is the mean and sigma the standard deviation."
-        configure(options)
+      distribution_name "Normal distribution"
+
+      distribution_description "Continuous distribution (mu,sigma) (defaults to (0,1) ) where mu is the mean and sigma the standard deviation."
+
+      cli_name "normal"
+
+      cli_options({
+        options: [
+          [:mean, 'mean of the distribution', {type: :float, default: 0.0}],
+          [:std, 'standard deviation of the distribution', {type: :float, default: 1.0}]
+        ],
+        banner: "Normal distribution. Generate numbers following a continuous distribution in the real line with mean :mean and standard deviation :std."
+      })
+
+      minimum_sample do
+        x, y = 1 - ::Croupier.rand, 1 - ::Croupier.rand
+        [
+          Math.sqrt(-2*Math.log(x)) * Math.cos(2*Math::PI*y),
+          Math.sqrt(-2*Math.log(x)) * Math.sin(2*Math::PI*y)
+        ]
       end
 
-      def generate_sample(n=1)
-        sample = n.odd? ? n+1 : n
-
-        # Generate
-        gen = (1..sample).map do |x|
-          1 - rand # because uniform need to be in (0,1]
-        end.each_slice(2).flat_map do |x, y|
-          [
-            Math.sqrt(-2*Math.log(x)) * Math.cos(2*Math::PI*y),
-            Math.sqrt(-2*Math.log(x)) * Math.sin(2*Math::PI*y)
-          ]
-        end
-
-        # Adjust parameters.
-        gen.map!{ |x| x * params[:std] }  if params[:std] != 1
-        gen.map!{ |x| x + params[:mean] } if params[:mean] != 0
-
-        # Adjust length
-        n.odd? ? gen[0..-2] : gen
+      def initialize(options={})
+        super(options)
       end
 
-      def default_parameters
-        {:mean => 0, :std => 1}
+      def std
+        params[:std]
       end
 
-      def self.cli_name
-        "normal"
+      def mean
+        params[:mean]
       end
 
-      def self.cli_options
-        {:options => [
-           [:mean, 'mean of the distribution', {:type=>:float, :default => 0.0}],
-           [:std, 'standard deviation of the distribution', {:type=>:float, :default => 1.0}]
-         ],
-         :banner => "Normal distribution. Generate numbers following a continuous distribution in the real line with mean :mean and standard deviation :std."
-        }
+      def to_enum
+        @generator.to_enum.
+          map {|x| x * std}.  # Adjust standard deviation
+          map {|x| x + mean}  # Adjust mean
       end
     end
   end

data/lib/croupier/distributions/poisson.rb

@@ -4,43 +4,44 @@ module Croupier
     #####################################################################
     # Poisson Distribution
     # Discrete probability distribution that expresses the probability
-    # of a given number of event occurrin in a fixed interval of time
+    # of a given number of event occurring in a fixed interval of time
     # and/or space if these events occur with a known average rate
     # and independently of the time since the las event.
     #
     # Wikipedia http://en.wikipedia.org/wiki/Poisson_distribution
     class Poisson < ::Croupier::Distribution
 
-      def initialize(options={})
-        @name = "Poisson distribution"
-        @description = "Discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time."
-        configure(options)
-      end
+      distribution_name "Poisson distribution"
 
-      def generate_number
-        l = Math.exp(-params[:lambda])
-        k = 0; p = 1;
-        while p > l
-          p *= rand
-          k += 1;
-        end
-        k-1
-      end
+      distribution_description "Discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time."
 
-      def default_parameters
-        {:lambda => 50}
+      cli_name "poisson"
+
+      cli_options({
+        options: [
+          [:lambda, 'rate parameter (equal to the mean of the distribution)', {type: :integer, default: 50}]
+        ],
+        banner: "Poisson distribution. Discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time."
+      })
+
+      enumerator_block do |y|
+        l = Math.exp(-lambda)
+        loop do
+          k = 0; p = 1
+          while p > l
+            p *= ::Croupier.rand
+            k += 1
+          end
+          y << (k-1)
+        end
       end
 
-      def self.cli_name
-        "poisson"
+      def initialize(options={})
+        super(options)
       end
 
-      def self.cli_options
-        {:options => [
-           [:lambda, 'rate parameter (equal to the mean of the distribution)', {:type=>:integer, :default => 50}]
-         ],
-         :banner => "Poisson distribution. Discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time."
-        }
+      def lambda
+        params[:lambda]
       end
     end
   end

data/lib/croupier/distributions/triangular.rb

@@ -7,42 +7,56 @@ module Croupier
     # is a, upper limit b and mode c (a <= c <= b).
     class Triangular < ::Croupier::Distribution
 
+      distribution_name "Triangular distribution"
+
+      distribution_description "Continuous probability distribution whose lower limit is a, upper limit b and mode c (a <= c <= b)"
+
+      cli_name "triangular"
+
+      cli_options({
+        options: [
+          [:lower, 'lower limit', {type: :float, short: '-a', default: 0.0}],
+          [:upper, 'upper limit', {type: :float, short: '-b', default: 1.0}],
+          [:mode, 'mode', {type: :float, short: '-c', default: 0.5}]
+        ],
+        banner: "Triangular distribution. Continuous distribution whose support is the interval (a,b), with mode c."
+      })
+
+      inv_cdf do |n|
+        if n < @F_c
+          lower + Math.sqrt(   n   * range * (mode - lower) )
+        else
+          upper - Math.sqrt( (1-n) * range * (upper - mode) )
+        end
+      end
+
       def initialize(options={})
-        @name = "Triangular distribution"
-        @description = "Continuous probability distribution whose lower limit is a, upper limit b and mode c (a <= c <= b)"
-        configure(options)
-        raise Croupier::InputParamsError, "Invalid interval values" if params[:a] >= params[:b]
-        if params[:c] < params[:a] || params[:b] <  params[:c]
+        super(options)
+        if params[:lower] >= params[:upper]
+          warn("Lower limit is greater than upper limit. Changing their values.")
+          params[:lower], params[:upper] = params[:upper], params[:lower]
+        end
+        if params[:mode] < params[:lower] || params[:upper] <  params[:mode]
           warn("Mode is not in the support. Mode value will be change to median.")
-          params[:c] = (params[:a]+params[:b])/2;
+          params[:mode] = (params[:lower]+params[:upper])/2.0;
         end
-        @F_c = (params[:c]-params[:a])/(params[:b]-params[:a])
+        @F_c = (params[:mode]-params[:lower]).to_f/(params[:upper]-params[:lower])
       end
 
-      def inv_cdf n
-        if n < @F_c
-          params[:a] + Math.sqrt(   n   * (params[:b] - params[:a]) * (params[:c] - params[:a]) )
-        else
-          params[:b] - Math.sqrt( (1-n) * (params[:b] - params[:a]) * (params[:b] - params[:c]) )
-        end
+      def lower
+        params[:lower]
       end
 
-      def default_parameters
-        {:a => 0.0, :b => 1.0, :c => 0.5}
+      def upper
+        params[:upper]
       end
 
-      def self.cli_name
-        "triangular"
+      def mode
+        params[:mode]
       end
 
-      def self.cli_options
-        {:options => [
-           [:a, 'lower limit', {:type=>:float, :default => 0.0}],
-           [:b, 'upper limit', {:type=>:float, :default => 1.0}],
-           [:c, 'mode'       , {:type=>:float, :default => 0.5}]
-         ],
-         :banner => "Triangular distribution. Continuous distribution whose support is the interval (a,b), with mode c."
-        }
+      def range
+        @range ||= upper - lower
       end
     end
   end

data/lib/croupier/distributions/uniform.rb

@@ -3,37 +3,61 @@ module Croupier
 
     #####################################################################
     # Uniform Distribution
-    # Continous distribution where all points in an interval have
+    # Continuous distribution where all points in an interval have
     # the same probability.
     #
     class Uniform < ::Croupier::Distribution
 
+      distribution_name "Uniform distribution"
+
+      distribution_description "Continuous distribution on [a,b] (defaults to [0,1]) where all points in the interval are equally likely"
+
+      cli_name "uniform"
+
+      cli_options({
+        options: [
+          [:included, 'interval included value', {type: :float, short: "-i", default: 0.0}],
+          [:excluded, 'interval excluded value', {type: :float, short: "-e", default: 1.0}]
+        ],
+        banner: "Uniform distribution. Generate numbers following a continuous distribution on [a,b] (given a=min(included, excluded) and b=max(included,excluded))  where all points in the interval are equally likely."
+      })
+
       def initialize(options={})
-        @name = "Uniform distribution"
-        @description = "Continuous distribution on [a,b] (defaults to [0,1]) where all points in the interval are equally likely"
-        configure(options)
+        super options
+        @exclude_value = if self.inverted?
+                           ->(n) { 1-n }
+                         else
+                           ->(n) { n }
+                         end
+        @min, @max = if self.inverted?
+                       [params[:excluded], params[:included]]
+                     else
+                       [params[:included], params[:excluded]]
+                     end
+        @range = @max - @min
       end
 
-      def generate_number
-        raise Croupier::InputParamsError, "Invalid interval values" if params[:b] < params[:a]
-        rand Range.new(params[:a], params[:b])
-      end
+      attr_reader :exclude_value, :min, :max, :range
 
-      def default_parameters
-        {:a => 0.0, :b => 1.0}
+      def inverted?
+        params[:included] > params[:excluded]
       end
 
-      def self.cli_name
-        "uniform"
+      def to_enum
+        @enum ||= base_enum.lazy.
+            map(&exclude_value).
+            map do |n|
+              min + range * n
+            end
       end
 
-      def self.cli_options
-        {:options => [
-           [:a, 'interval start value', {:type=>:float, :default => 0.0}],
-           [:b, 'interval end value', {:type=>:float, :default => 1.0}]
-         ],
-         :banner => "Uniform distribution. Generate numbers following a continuous distribution on [a,b] (defaults to [0,1]) where all points in the interval are equally likely"
-        }
+      protected
+      def base_enum
+        Enumerator.new do |y|
+          loop do
+            y << Croupier.rand
+          end
+        end
       end
     end
   end