random_variates 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d30e6b62a53350bfd18a1deb7d5338c98d7fcd479a9f5020ff7bc6e8358c256
-  data.tar.gz: 33a02922156dc7b17b9aada61693562aca6a12cf059f2e5fa775f52b7de10bc0
+  metadata.gz: 43a85c7f9cd47a418101215d490e1089ab8b5867f860c6200359c2d1f08079a2
+  data.tar.gz: 6bb665672cbbfcd7b281739acc3e78437ad8a2632e21208559d9a5b4dc380645
 SHA512:
-  metadata.gz: d2d6f766aa38c6647c4f184fb279854597f7bee784b007ca1da35a3791200645872e5cc433270ce14a094408a360afac313170e155bb451653a43be03996cae4
-  data.tar.gz: 82ea2362281c4eb8fe9ee0168f88df8a77333530d8a693cafd7a5ecc5490efea05167561a2458c3b65d21033a35ac791afecb667185cdaa72e1c681907959904
+  metadata.gz: 5741f020d080a4e2a2e2dec67e3654eeb6e8cd5ea4725881ccb94f7b2b1b9efbfc38548bcadae625f2b68e36d868209259fc485c6d30007eed11b2154bb65df8
+  data.tar.gz: f5f8821ecf11b76639c8e1c63391dbbfc5f490617da946a49d157dee1c9f749a6d41755a5ae1abcc4b4000743c8db358654e0ff7e7840b7af2740c7afd7fa1b3

data/LICENSE.md

@@ -1,7 +1,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2018 Paul J. Sanchez
+Copyright (c) 2020 Paul J. Sanchez
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,13 +1,25 @@
+### DESCRIPTION
+
 This gem implements random variate generation for several
 common statistical distributions.  Each distribution is implemented
 in its own class, and different parameterizations are created as
 instances of the class using the constructor to specify the
 parameterization.  All constructors use named parameters for clarity,
 so the order of parameters does not matter. All random variate classes
-provide an optional argument `rng`, with which the user can specify an
-enumerable U(0,1) generator to use as the core source of randomness.
-If `rng` is not specified, it defaults to Ruby's `Kernel#rand`.
+provide an optional argument `rng`, with which the user can specify a
+U(0,1) generator as an `Enumerator` to use as the core source of randomness.
+If `rng` is not specified, it is based on Ruby's `Kernel#rand`.
 
 Once a random variate class has been instantiated, values can either be
 generated on demand using the `next` method or by using the instance as
-a generator in any iterable context.
+a generator in any iterable context.  Since these are "infinite" generators, enumerative Ruby methods such as `.first` or `.take` will require a `.each` first to yield an iterator for lazy access.  Example: `my_exp = RV::Exponential.new(rate: 3); my_exp.each.take(50)` will yield an array of fifty exponentially distributed values having rate 3.
+
+---
+
+### RELEASE NOTES
+
+**v0.4**
+ - All distribution classes have been placed in a module called `RV` to try to avoid namespace conflicts.
+ - The `Gaussian` class has been renamed, it is now the `Normal` class.
+ - Parameters for `Gaussian` and `BoxMuller` have been renamed.  They are now `mu:` and `sigma:`.
+ - `Exponential`, `Normal`, and `BoxMuller` distribution parameters can now be set to new values without having to instantiate an entirely new generator object.

data/lib/random_variates.rb

@@ -14,421 +14,471 @@
 # generated on demand using the +next+ method or by using the instance as
 # a generator in any iterable context.
 
-# Provide access to +Kernel#rand+ as an +Enumerator+ object.
-U_GENERATOR = Enumerator.new { |yielder| loop { yielder << rand } }
-
-# The +RV_Generator+ module provides a common core of methods to make
-# all of the RV classes +Enumerable+.
-module RV_Generator
-  include Enumerable
-
-  attr_reader :generator
-
-  def next
-    @generator.next
-  end
+module RV
+  # Provide access to +Kernel#rand+ as an +Enumerator+.
+  U_GENERATOR = Enumerator.new { |yielder| loop { yielder << rand } }
+
+  # The +RV_Generator+ module provides a common core of methods to make
+  # all of the RV classes iterable.
+  module RV_Generator
+    def next
+      raise 'next not implemented!'
+    end
 
-  def each
-    loop { yield @generator.next }
+    def each
+      Enumerator.new { |y| loop { y << self.next } }
+    end
   end
-end
 
-# Generate values uniformly distributed between +min+ and +max+.
-#
-# *Arguments*::
-#   - +min+ -> the lower bound for the range (default: 0).
-#   - +max+ -> the upper bound for the range (default: 1).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Uniform
-  include RV_Generator
-
-  attr_reader :min, :max
-
-  def initialize(min: 0.0, max: 1.0, rng: U_GENERATOR)
-    raise 'Max must be greater than min.' if max <= min
+  # Generate values uniformly distributed between +min+ and +max+.
+  #
+  # *Arguments*::
+  #   - +min+ -> the lower bound for the range (default: 0).
+  #   - +max+ -> the upper bound for the range (default: 1).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Uniform
+    include RV_Generator
+
+    attr_reader :min, :max, :range
+
+    def initialize(min: 0.0, max: 1.0, rng: U_GENERATOR)
+      raise 'Max must be greater than min.' if max <= min
+      @min = min
+      @max = max
+      @range = max - min
+      @rng = rng
+    end
 
-    @min = min
-    @max = max
-    range = max - min
-    @generator = Enumerator.new do |yielder|
-      loop { yielder << (min + range * rng.next) }
+    def next
+      @min + @range * @rng.next
     end
   end
-end
 
-# Triangular random variate generator with specified +min+, +mode+, and +max+.
-#
-# *Arguments*::
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#   - +min+ -> the lower bound for the range.
-#   - +max+ -> the upper bound for the range.
-#   - +mode+ -> the highest likelihood value (+min+ ≤ +mode+ ≤ +max+).
-#   - +mean+ -> the expected value of the distribution.
-#
-class Triangle
-  include RV_Generator
-
-  attr_reader :min, :max, :mode, :range, :mean
-
-  def initialize(rng: U_GENERATOR, **args)
-    param_names = %i[mean min max mode]
-    unless args.size > 2 && args.keys.all? { |k| param_names.include? k }
-      raise "invalid args - can only be #{param_names.join ', '}, or rng."
-    end
+  # Triangular random variate generator with specified +min+, +mode+, and +max+.
+  #
+  # *Arguments*::
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #   - +min+ -> the lower bound for the range.
+  #   - +max+ -> the upper bound for the range.
+  #   - +mode+ -> the highest likelihood value (+min+ ≤ +mode+ ≤ +max+).
+  #   - +mean+ -> the expected value of the distribution.
+  #
+  class Triangle
+    include RV_Generator
+
+    attr_reader :min, :max, :mode, :range, :mean
+
+    def initialize(rng: U_GENERATOR, **args)
+      param_names = %i[mean min max mode]
+      unless args.size > 2 && args.keys.all? { |k| param_names.include? k }
+        raise "invalid args - can only be #{param_names.join ', '}, or rng."
+      end
 
-    param_names.each { |k| args[k] ||= nil } if args.size < param_names.size
+      param_names.each { |k| args[k] ||= nil } if args.size < param_names.size
 
-    nil_args = args.select { |_, v| v.nil? }.keys
-    nil_args_count = nil_args.count
-    raise 'too many nil args' if nil_args_count > 1
+      nil_args = args.select { |_, v| v.nil? }.keys
+      nil_args_count = nil_args.count
+      raise 'too many nil args' if nil_args_count > 1
 
-    args.transform_values! &:to_f
+      args.transform_values! &:to_f
 
-    if nil_args_count == 0
-      if args[:mean] != (args[:min] + args[:max] + args[:mode]) / 3.0
-        raise 'inconsistent args'
-      end
-    else
-      key = nil_args.shift
-      case key
-      when :mean
-        args[key] = (args[:min] + args[:max] + args[:mode]) / 3.0
+      if nil_args_count == 0
+        if args[:mean] != (args[:min] + args[:max] + args[:mode]) / 3.0
+          raise 'inconsistent args'
+        end
       else
-        others = param_names - [key, :mean]
-        args[key] = 3 * args[:mean] - args.values_at(*others).sum
+        key = nil_args.shift
+        case key
+        when :mean
+          args[key] = (args[:min] + args[:max] + args[:mode]) / 3.0
+        else
+          others = param_names - [key, :mean]
+          args[key] = 3 * args[:mean] - args.values_at(*others).sum
+        end
       end
-    end
 
-    param_names.each { |parm| instance_variable_set("@#{parm}", args[parm]) }
+      param_names.each { |parm| instance_variable_set("@#{parm}", args[parm]) }
 
-    @range = @max - @min
-    raise 'Min must be less than Max.' if @range <= 0
-    raise 'Mode must be between Min and Max.' unless (@min..@max).include? @mode
-
-    crossover_p = (@mode - @min).to_f / @range
-    @generator = Enumerator.new do |yielder|
-      loop do
-        u = rng.next
-        yielder << (
-          u < crossover_p ?
-            @min + Math.sqrt(@range * (@mode - @min) * u) :
-            @max - Math.sqrt(@range * (@max - @mode) * (1.0 - u))
-        )
+      @rng = rng
+      @range = @max - @min
+      raise 'Min must be less than Max.' if @range <= 0
+      unless (@min..@max).include? @mode
+        raise 'Mode must be between Min and Max.'
       end
+      @crossover_p = (@mode - @min).to_f / @range
+    end
+
+    def next
+      u = @rng.next
+      u < @crossover_p ?
+        @min + Math.sqrt(@range * (@mode - @min) * u) :
+        @max - Math.sqrt(@range * (@max - @mode) * (1.0 - u))
     end
   end
-end
 
-# Exponential random variate generator with specified +rate+ or +mean+.
-# One and only one of +rate+ or +mean+ should be specified.
-#
-# *Arguments*::
-#   - +rate+ -> the rate of occurrences per unit time (default: +nil+).
-#   - +mean+ -> the expected value of the distribution (default: +nil+).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Exponential
-  include RV_Generator
+  # Exponential random variate generator with specified +rate+ or +mean+.
+  # One and only one of +rate+ or +mean+ should be specified.
+  #
+  # *Arguments*::
+  #   - +rate+ -> the rate of occurrences per unit time (default: +nil+).
+  #   - +mean+ -> the expected value of the distribution (default: +nil+).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Exponential
+    include RV_Generator
+
+    attr_reader :rate, :mean
+
+    def initialize(rate: nil, mean: nil, rng: U_GENERATOR)
+      raise 'Rate must be positive.' if rate && rate <= 0
+      raise 'Mean must be positive.' if mean && mean <= 0
+      unless rate.nil? ^ mean.nil?
+        raise 'Supply one and only one of mean or rate'
+      end
 
-  attr_reader :rate, :mean
+      if rate.nil?
+        @mean = mean
+        @rate = 1.0 / mean
+      else
+        @mean = 1.0 / rate
+        @rate = rate
+      end
+      @rng = rng
+    end
 
-  def initialize(rate: nil, mean: nil, rng: U_GENERATOR)
-    raise 'Rate must be positive.' if rate && rate <= 0
-    raise 'Mean must be positive.' if mean && mean <= 0
-    raise 'Supply one and only one of mean or rate' unless rate.nil? ^ mean.nil?
+    def next
+      -@mean * Math.log(@rng.next)
+    end
 
-    if rate.nil?
-      @mean = mean
-      @rate = 1.0 / mean
-    else
+    def rate=(rate)
+      raise 'Rate must be a number.' unless rate.is_a? Number
+      raise 'Rate must be positive.' if rate <= 0
       @mean = 1.0 / rate
       @rate = rate
     end
-    @generator = Enumerator.new do |yielder|
-      loop { yielder << (-@mean * Math.log(rng.next)) }
+
+    def mean=(mean)
+      raise 'Mean must be a number.' unless mean.is_a? Number
+      raise 'Mean must be positive.' if mean <= 0
+      @mean = mean
+      @rate = 1.0 / mean
     end
   end
-end
-
-# Gaussian/normal random variate generator with specified
-# +mean+ and +standard deviation+.  Defaults to a standard normal.
-#
-# *Arguments*::
-#   - +mean+ -> the expected value (default: 0).
-#   - +sd+ -> the standard deviation (default: 1).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Gaussian
-  include RV_Generator
 
-  attr_reader :mean, :sd
-
-  def initialize(mean: 0.0, sd: 1.0, rng: U_GENERATOR)
-    raise 'Standard deviation must be positive.' if sd <= 0
+  # Normal/Gaussian random variate generator with specified
+  # +mean+ and +standard deviation+.  Defaults to a standard normal.
+  #
+  # *Arguments*::
+  #   - +mu+ -> the expected value (default: 0).
+  #   - +sigma+ -> the standard deviation (default: 1).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Normal
+    include RV_Generator
+    BOUND = 2.0 * Math.sqrt(2.0 / Math::E)
+
+    attr_reader :mu, :sigma
+
+    def initialize(mu: 0.0, sigma: 1.0, rng: U_GENERATOR)
+      raise 'Standard deviation must be positive.' if sigma <= 0
+
+      @mu = mu
+      @sigma = sigma
+      @rng = rng
+    end
 
-    @mean = mean
-    @sd = sd
-    @generator = Enumerator.new do |yielder|
-      # Ratio of Uniforms
-      bound = 2.0 * Math.sqrt(2.0 / Math::E)
+    def next
       loop do
-        u = rng.next
+        u = @rng.next
         next if u == 0.0
-
-        v = bound * (rng.next - 0.5)
+        v = BOUND * (@rng.next - 0.5)
         x = v / u
         x_sqr = x * x
         u_sqr = u * u
         if 6.0 * x_sqr <= 44.0 - 72.0 * u + 36.0 * u_sqr - 8.0 * u * u_sqr
-          yielder << sd * x + mean
+          return @sigma * x + @mu
         elsif x_sqr * u >= 2.0 - 2.0 * u_sqr
           next
         elsif x_sqr <= -4.0 * Math.log(u)
-          yielder << sd * x + mean
+          return @sigma * x + @mu
         end
       end
     end
-  end
-end
 
-# Alternate Gaussian/normal random variate generator with specified
-# +mean+ and +standard deviation+.  Defaults to a standard normal.
-#
-# *Arguments*::
-#   - +mean+ -> the expected value (default: 0).
-#   - +sd+ -> the standard deviation (default: 1).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class BoxMuller
-  include RV_Generator
+    def sigma=(sigma)
+      raise 'sigma must be a number.' unless sigma.is_a? Number
+      @sigma = sigma
+    end
 
-  attr_reader :mean, :sd
+    def mu=(mu)
+      raise 'mu must be a number.' unless mu.is_a? Number
+      @mu = mu
+    end
+  end
 
-  def initialize(mean: 0.0, sd: 1.0, rng: U_GENERATOR)
-    raise 'Standard deviation must be positive.' if sd <= 0
+  # Alternate normal/Gaussian random variate generator with specified
+  # +mean+ and +standard deviation+.  Defaults to a standard normal.
+  #
+  # *Arguments*::
+  #   - +mu+ -> the expected value (default: 0).
+  #   - +sigma+ -> the standard deviation (default: 1).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class BoxMuller
+    include RV_Generator
+    TWO_PI = 2.0 * Math::PI
+
+    attr_reader :mu, :sigma
+
+    def initialize(mu: 0.0, sigma: 1.0, rng: U_GENERATOR)
+      raise 'Standard deviation must be positive.' if sigma <= 0
+
+      @mu = mu
+      @sigma = sigma
+      @rng = rng
+      @need_new_pair = false
+      # @next_norm = 0.0
+    end
 
-    @mean = mean
-    @sd = sd
-    @generator = Enumerator.new do |yielder|
-      # Box-Muller
-      next_z = 0.0
-      need_new_pair = false
-      loop do
-        need_new_pair ^= true
-        if need_new_pair
-          theta = 2.0 * Math::PI * rng.next
-          d = sd * Math.sqrt(-2.0 * Math.log(rng.next))
-          next_z = mean + d * Math.sin(theta)
-          yielder << mean + d * Math.cos(theta)
-        else
-          yielder << next_z
-        end
+    def next
+      if @need_new_pair ^= true
+        theta = TWO_PI * @rng.next
+        d = @sigma * Math.sqrt(-2.0 * Math.log(@rng.next))
+        @next_norm = @mu + d * Math.sin(theta)
+        @mu + d * Math.cos(theta)
+      else
+        @next_norm
       end
     end
-  end
-end
 
-# Gamma generator based on Marsaglia and Tsang method Algorithm 4.33
-#
-# Produces gamma RVs with expected value +alpha+ * +beta+.
-#
-# *Arguments*::
-#   - +alpha+ -> the shape parameter (+alpha+ > 0; default: 1).
-#   - +beta+ -> the rate parameter (+beta+ > 0; default: 1).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Gamma
-  include RV_Generator
+    def sigma=(sigma)
+      raise 'sigma must be a number.' unless sigma.is_a? Number
+      @sigma = sigma
+    end
 
-  attr_reader :alpha, :beta
+    def mu=(mu)
+      raise 'mu must be a number.' unless mu.is_a? Number
+      @mu = mu
+    end
+  end
 
-  def initialize(alpha: 1.0, beta: 1.0, rng: U_GENERATOR)
-    raise 'Alpha and beta must be positive.' if alpha <= 0 || beta <= 0
+  # Gamma generator based on Marsaglia and Tsang method Algorithm 4.33
+  #
+  # Produces gamma RVs with expected value +alpha+ * +beta+.
+  #
+  # *Arguments*::
+  #   - +alpha+ -> the shape parameter (+alpha+ > 0; default: 1).
+  #   - +beta+ -> the rate parameter (+beta+ > 0; default: 1).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Gamma
+    include RV_Generator
+
+    attr_reader :alpha, :beta
+
+    def initialize(alpha: 1.0, beta: 1.0, rng: U_GENERATOR)
+      raise 'Alpha and beta must be positive.' if alpha <= 0 || beta <= 0
+
+      @alpha = alpha
+      @beta = beta
+      @rng = rng
+      @std_normal = Normal.new(rng: rng)
+    end
 
-    @alpha = alpha
-    @beta = beta
-    std_normal = Gaussian.new(mean: 0.0, sd: 1.0, rng: rng)
-    @generator = Enumerator.new do |yielder|
-      loop { yielder << __gen__(alpha, beta, std_normal, rng) }
+    def next
+      __gen__(@alpha, @beta)
     end
-  end
 
-  private
+    private
 
-  def __gen__(alpha, beta, std_normal, rng)
-    if alpha > 1
-      z = v = 0.0
-      d = alpha - 1.0 / 3.0
-      c = (1.0 / 3.0) / Math.sqrt(d)
-      loop do
+    def __gen__(alpha, beta)
+      if alpha > 1
+        z = v = 0.0
+        d = alpha - 1.0 / 3.0
+        c = (1.0 / 3.0) / Math.sqrt(d)
         loop do
-          z = std_normal.next
-          v = 1.0 + c * z
-          break if v > 0
+          loop do
+            z = @std_normal.next
+            v = 1.0 + c * z
+            break if v > 0
+          end
+          z2 = z * z
+          v = v * v * v
+          u = @rng.next
+          break if u < 1.0 - 0.0331 * z2 * z2
+          break if Math.log(u) < (0.5 * z2 + d * (1.0 - v + Math.log(v)))
         end
-        z2 = z * z
-        v = v * v * v
-        u = rng.next
-        break if u < 1.0 - 0.0331 * z2 * z2
-        break if Math.log(u) < (0.5 * z2 + d * (1.0 - v + Math.log(v)))
+        d * v * beta
+      else
+        __gen__(alpha + 1.0, beta) * (@rng.next**(1.0 / alpha))
       end
-      d * v * beta
-    else
-      __gen__(alpha + 1.0, beta, std_normal, rng) * (rng.next**(1.0 / alpha))
     end
   end
-end
 
-# Weibull generator based on Devroye
-#
-# *Arguments*::
-#   - +rate+ -> the scale parameter (+rate+ > 0; default: 1).
-#   - +k+ -> the shape parameter (+k+ > 0; default: 1).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Weibull
-  include RV_Generator
+  # Weibull generator based on Devroye
+  #
+  # *Arguments*::
+  #   - +rate+ -> the scale parameter (+rate+ > 0; default: 1).
+  #   - +k+ -> the shape parameter (+k+ > 0; default: 1).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Weibull
+    include RV_Generator
 
-  attr_reader :rate, :k
+    attr_reader :rate, :k
 
-  def initialize(rate: 1.0, k: 1.0, rng: U_GENERATOR)
-    raise 'Rate and k must be positive.' if rate <= 0 || k <= 0
+    def initialize(rate: 1.0, k: 1.0, rng: U_GENERATOR)
+      raise 'Rate and k must be positive.' if rate <= 0 || k <= 0
 
-    @rate = rate
-    @k = k
-    power = 1.0 / k
-    @generator = Enumerator.new do |yielder|
-      loop { yielder << (-Math.log(rng.next))**power / rate }
+      @rate = rate
+      @k = k
+      @rng = rng
+      @power = 1.0 / k
     end
-  end
-end
 
-# Erlang generator - Weibull restricted to integer +k+
-#
-# *Arguments*::
-#   - +rate+ -> the scale parameter (+rate+ > 0; default: 1).
-#   - +k+ -> the shape parameter (+k+ > 0; default: 1).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Erlang < Weibull
-  def initialize(rate: 1.0, k: 1, rng: U_GENERATOR)
-    raise 'K must be integer.' unless k.integer?
-
-    super(rate: rate, k: k, rng: rng)
+    def next
+      (-Math.log(@rng.next))**@power / @rate
+    end
   end
-end
 
-# von Mises generator.
-#
-# This von Mises distribution generator is based on the VML algorithm by
-# L. Barabesis: "Generating von Mises variates by the Ratio-of-Uniforms Method"
-# Statistica Applicata Vol. 7, #4, 1995
-# http://sa-ijas.stat.unipd.it/sites/sa-ijas.stat.unipd.it/files/417-426.pdf
-#
-# *Arguments*::
-#   - +kappa+ -> concentration coefficient (+kappa+ ≥ 0).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class VonMises
-  include RV_Generator
+  # Erlang generator - Weibull restricted to integer +k+
+  #
+  # *Arguments*::
+  #   - +rate+ -> the scale parameter (+rate+ > 0; default: 1).
+  #   - +k+ -> the shape parameter (+k+ > 0; default: 1).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Erlang < Weibull
+    def initialize(rate: 1.0, k: 1, rng: U_GENERATOR)
+      raise 'K must be integer.' unless k.integer?
+
+      super(rate: rate, k: k, rng: rng)
+    end
+  end
 
-  attr_reader :kappa
+  # von Mises generator.
+  #
+  # This von Mises distribution generator is based on the VML algorithm by
+  # L. Barabesis: "Generating von Mises variates by the Ratio-of-Uniforms Method"
+  # Statistica Applicata Vol. 7, #4, 1995
+  # http://sa-ijas.stat.unipd.it/sites/sa-ijas.stat.unipd.it/files/417-426.pdf
+  #
+  # *Arguments*::
+  #   - +kappa+ -> concentration coefficient (+kappa+ ≥ 0).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class VonMises
+    include RV_Generator
+
+    attr_reader :kappa
+
+    def initialize(kappa:, rng: U_GENERATOR)
+      raise 'kappa must be positive.' if kappa < 0
+      @kappa = kappa
+      @rng = rng
+      @s = (kappa > 1.3 ? 1.0 / Math.sqrt(kappa) : Math::PI * Math.exp(-kappa))
+    end
 
-  def initialize(kappa:, rng: U_GENERATOR)
-    raise 'kappa must be positive.' if kappa < 0
-    s = (kappa > 1.3 ? 1.0 / Math.sqrt(kappa) : Math::PI * Math.exp(-kappa))
-    @generator = Enumerator.new do |yielder|
+    def next
       loop do
-        r1 = rng.next
-        theta = s * (2.0 * rng.next - 1.0) / r1
-        next if (theta.abs > Math::PI)
-        yielder << theta if (0.25 * kappa * theta * theta < 1.0 - r1) ||
-                      (0.5 * kappa * (Math.cos(theta) - 1.0) >= Math.log(r1))
+        r1 = @rng.next
+        theta = @s * (2.0 * @rng.next - 1.0) / r1
+        next if theta.abs > Math::PI
+        return theta if (0.25 * @kappa * theta * theta < 1.0 - r1) ||
+                        (0.5 * @kappa * (Math.cos(theta) - 1.0) >= Math.log(r1))
       end
     end
   end
-end
 
-# Poisson generator.
-#
-# *Arguments*::
-#   - +rate+ -> expected number per unit time/distance (+rate+ > 0; default: 1).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Poisson
-  include RV_Generator
+  # Poisson generator.
+  #
+  # *Arguments*::
+  #   - +rate+ -> expected number per unit time/distance (+rate+ > 0; default: 1).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Poisson
+    include RV_Generator
 
-  attr_reader :rate
+    attr_reader :rate
 
-  def initialize(rate: 1.0, rng: U_GENERATOR)
-    raise 'rate must be positive.' if rate <= 0
+    def initialize(rate: 1.0, rng: U_GENERATOR)
+      raise 'rate must be positive.' if rate <= 0
 
-    @rate = rate
-    threshold = Math.exp(-rate)
-    @generator = Enumerator.new do |yielder|
-      loop do
-        count = 0
-        product = 1.0
-        count += 1 until (product *= rng.next) < threshold
-        yielder << count
-      end
+      @rate = rate
+      @threshold = Math.exp(-rate)
+      @rng = rng
+    end
+
+    def next
+      count = 0
+      product = 1.0
+      count += 1 until (product *= @rng.next) < @threshold
+      count
     end
   end
-end
 
-# Geometric generator.  Number of trials until first "success".
-#
-# *Arguments*::
-#   - +p+ -> the probability of success (0 < +p+ < 1; default: 0.5).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Geometric
-  include RV_Generator
+  # Geometric generator.  Number of trials until first "success".
+  #
+  # *Arguments*::
+  #   - +p+ -> the probability of success (0 < +p+ < 1; default: 0.5).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Geometric
+    include RV_Generator
 
-  attr_reader :p
+    attr_reader :p
 
-  def initialize(p: 0.5, rng: U_GENERATOR)
-    raise 'Require 0 < p < 1.' if p <= 0 || p >= 1
+    def initialize(p: 0.5, rng: U_GENERATOR)
+      raise 'Require 0 < p < 1.' if p <= 0 || p >= 1
 
-    @p = p
-    log_q = Math.log(1 - p)
-    @generator = Enumerator.new do |yielder|
-      loop { yielder << (Math.log(1.0 - rng.next) / log_q).ceil }
+      @p = p
+      @log_q = Math.log(1 - p)
+      @rng = rng
     end
-  end
-end
 
-# Binomial generator.  Number of "successes" in +n+ independent trials.
-#
-# *Arguments*::
-#   - +n+ -> the number of trials (+p+ > 0, integer; default: 1).
-#   - +p+ -> the probability of success (0 < +p+ < 1; default: 0.5).
-#   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
-#
-class Binomial
-  include RV_Generator
-
-  attr_reader :n, :p
+    def next
+      (Math.log(1.0 - @rng.next) / @log_q).ceil
+    end
+  end
 
-  def initialize(n: 1, p: 0.5, rng: U_GENERATOR)
-    raise 'N must be a positive integer.' if n.to_i != n || n <= 0
-    raise 'Require 0 < p < 1.' if p <= 0 || p >= 1
+  # Binomial generator.  Number of "successes" in +n+ independent trials.
+  #
+  # *Arguments*::
+  #   - +n+ -> the number of trials (+p+ > 0, integer; default: 1).
+  #   - +p+ -> the probability of success (0 < +p+ < 1; default: 0.5).
+  #   - +rng+ -> the (+Enumerable+) source of U(0, 1)'s (default: U_GENERATOR)
+  #
+  class Binomial
+    include RV_Generator
+
+    attr_reader :n, :p
+
+    def initialize(n: 1, p: 0.5, rng: U_GENERATOR)
+      raise 'N must be an integer.' unless n.is_a? Integer
+      raise 'N must be positive.' if n <= 0
+      raise 'Require 0 < p < 1.' if p <= 0 || p >= 1
+
+      @n = n.to_i
+      @p = p
+      @complement = false
+      if @p <= 0.5
+        @log_q = Math.log(1 - p)
+      else
+        @log_q = Math.log(@p)
+        @complement = true
+      end
+      @rng = rng
+    end
 
-    @n = n.to_i
-    @p = p
-    log_q = Math.log(1 - p)
-    @generator = Enumerator.new do |yielder|
+    def next
+      result = sum = 0
       loop do
-        result = sum = 0
-        loop do
-          sum += Math.log(rng.next) / (n - result)
-          break if sum < log_q
-
-          result += 1
-        end
-        yielder << result
+        sum += Math.log(@rng.next) / (@n - result)
+        break if sum < @log_q
+        result += 1
       end
+      @complement ? @n - result : result
     end
   end
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: random_variates
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Paul J Sanchez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-28 00:00:00.000000000 Z
+date: 2020-05-02 00:00:00.000000000 Z
 dependencies: []
-description: Random variate generators implemented as enumerator/enumerable.
+description: Random variate generators implemented as enumerators.
 email: pjs@alum.mit.edu
 executables: []
 extensions: []
@@ -19,7 +19,7 @@ files:
 - LICENSE.md
 - README.md
 - lib/random_variates.rb
-homepage: 
+homepage: https://bitbucket.org/paul_j_sanchez/random_variates.git
 licenses:
 - MIT
 metadata: {}
@@ -31,14 +31,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Random variate generator classes.