croupier 1.6.0 → 2.0.0.rc1

data/lib/croupier/distributions.rb

@@ -4,9 +4,9 @@ module Croupier
     class << self
       # An array containing all available Distribution classes
       def all
-        ::Croupier::Distributions.constants(false).inject([]){|list, distrib|
+        ::Croupier::Distributions.constants(false).each_with_object([]){|distrib, list|
           d = ::Croupier::Distributions.const_get(distrib)
-          (d.is_a?(Class) && d.superclass == Croupier::Distribution) ? list << d : list
+          list << d if (d.is_a?(Class) && d.superclass == Croupier::Distribution)
         }.uniq.compact
       end
 
@@ -17,7 +17,7 @@ module Croupier
 
       def method_missing(method, *args, &block) # :nodoc:
         return super unless self.respond_to?(method)
-        self.all.select{|d| d.cli_name == method.to_s}.first.new *args
+        self.all.find{|d| d.cli_name == method.to_s}.new(*args)
       end
 
       def respond_to?(method, include_private = false) # :nodoc:
@@ -25,5 +25,4 @@ module Croupier
       end
     end
   end
-
 end

data/lib/croupier/version.rb

@@ -1,3 +1,3 @@
 module Croupier
-  VERSION = "1.6.0"
+  VERSION = "2.0.0.rc1"
 end

data/lib/croupier.rb

@@ -1,10 +1,13 @@
-require 'croupier/version'
-require 'croupier/cli/trollop'
-require 'croupier/exceptions'
-require 'croupier/distribution'
-require 'croupier/distributions'
+require_relative 'croupier/version'
+require_relative 'croupier/cli/trollop'
+require_relative 'croupier/exceptions'
+require_relative 'croupier/distribution_generator'
+require_relative 'croupier/distribution_generators'
+Dir[File.join(File.dirname(__FILE__), "./croupier/distribution_generators/*.rb")].each {|f| require f}
+require_relative 'croupier/distribution'
+require_relative 'croupier/distributions'
 Dir[File.join(File.dirname(__FILE__), "./croupier/distributions/*.rb")].each {|f| require f}
-require 'croupier/cli/application'
+require_relative 'croupier/cli/application'
 #####################################################################
 # Croupier module.
 # Used as a namespace containing all the Croupier code.
@@ -62,5 +65,39 @@ module Croupier
         Croupier.stop("\nCroupier Exiting... Interrupt signal received.")
       end
     end
+
+    ## Random generator related stuff.
+
+    # Same as Random#rand applied to Croupier random object.
+    #
+    # @return random number x, 0 <= x < 1
+    def rand *args
+      random.rand *args
+    end
+
+    # Sets Croupier random generator to a new object
+    # with provided seed.
+    # If seed is omitted, a new Random object is created
+    # without explicit seed.
+    # @param seed [Numeric] optional seed
+    # @return [NilClass] nil
+    def srand(seed=nil)
+      @random_generator = seed ? Random.new(seed) : Random.new
+      nil
+    end
+
+    # Croupier Random object
+    #
+    # @return [Random] croupier random object
+    def random
+      @random_generator ||= Random.new
+    end
+
+    # Croupier Random object seed.
+    #
+    # @return [Numeric] croupier random object seed
+    def seed
+      random.seed
+    end
   end
 end

data/test/minitest/distribution_class/test_class_methods.rb

@@ -0,0 +1,142 @@
+require 'minitest/autorun'
+require 'croupier'
+
+class TestDistributionClassClassMethods < MiniTest::Unit::TestCase
+
+  def distribution_subclass_with_name name
+    Class.new Croupier::Distribution do
+      distribution_name name
+    end
+  end
+
+  def distribution_subclass_with_description description
+    Class.new Croupier::Distribution do
+      distribution_description description
+    end
+  end
+
+  def distribution_subclass_with_generator_class klazz
+    Class.new Croupier::Distribution do
+      generator_class klazz
+    end
+  end
+
+  def distribution_subclass_with_generator_block &block
+    Class.new Croupier::Distribution do
+      generator_block &block
+    end
+  end
+
+  def distribution_subclass_with_cli_options opts
+    Class.new Croupier::Distribution do
+      cli_options opts
+    end
+  end
+
+  def distribution_subclass_with_cli_name name
+    Class.new Croupier::Distribution do
+      cli_name name
+    end
+  end
+
+  def test_name_setter_adds_the_name
+    a = distribution_subclass_with_name "My name"
+    assert_equal "My name", a.distribution_name
+  end
+
+  def test_name_sets_separated_names_for_each_subclass
+    a = distribution_subclass_with_name "A"
+    b = distribution_subclass_with_name "B"
+    assert_equal "A", a.distribution_name
+    assert_equal "B", b.distribution_name
+    assert_nil Croupier::Distribution.distribution_name
+  end
+
+  def test_description_setter_adds_the_description
+    a = distribution_subclass_with_description "My desc"
+    assert_equal "My desc", a.distribution_description
+  end
+
+  def test_description_sets_separated_descriptions_for_each_subclass
+    a = distribution_subclass_with_description "A"
+    b = distribution_subclass_with_description "B"
+    assert_equal "A", a.distribution_description
+    assert_equal "B", b.distribution_description
+    assert_nil Croupier::Distribution.distribution_description
+  end
+
+  def test_cli_name_setter_adds_the_cli_name
+    a = distribution_subclass_with_cli_name "name"
+    assert_equal "name", a.cli_name
+  end
+
+  def test_cli_name_sets_separated_names_for_each_subclass
+    a = distribution_subclass_with_cli_name "a"
+    b = distribution_subclass_with_cli_name "b"
+    assert_equal "a", a.cli_name
+    assert_equal "b", b.cli_name
+    assert_nil Croupier::Distribution.cli_name
+  end
+
+  def test_cli_options_setter_adds_the_options
+    opts = Hash.new
+    a = distribution_subclass_with_cli_options opts
+    assert_equal opts, a.cli_options
+  end
+
+  def test_default_parameters_correctly_computed_from_cli_options
+    opts = {banner: 'Something', options: [[:a, "A", {type: :float, default: 0.5}], [:b, "B", {type: :float, default: 0.7}]]}
+    a = distribution_subclass_with_cli_options opts
+    assert_equal 0.5, a.default_parameters[:a]
+    assert_equal 0.7, a.default_parameters[:b]
+  end
+
+  def test_cli_options_sets_separated_cli_options_for_each_subclass
+    ha = Hash.new
+    hb = Hash.new
+    a = distribution_subclass_with_cli_options ha
+    b = distribution_subclass_with_cli_options hb
+    assert_equal ha, a.cli_options
+    assert_equal hb, b.cli_options
+    assert_empty Croupier::Distribution.cli_options
+  end
+
+  def test_responds_to_generators_methods
+    assert_respond_to ::Croupier::Distribution, 'inv_cdf'
+    assert_respond_to ::Croupier::Distribution, 'minimum_sample'
+    assert_respond_to ::Croupier::Distribution, 'enumerator_block'
+    assert_respond_to ::Croupier::Distribution, 'enumerator'
+  end
+
+  def test_generator_class_setter_adds_generator_class
+    klazz = Class.new
+    a = distribution_subclass_with_generator_class klazz
+    assert_equal klazz, a.generator_class
+  end
+
+  def test_generator_class_sets_separated_classes_for_each_subclass
+    ka = Class.new
+    kb = Class.new
+    a = distribution_subclass_with_generator_class ka
+    b = distribution_subclass_with_generator_class kb
+    assert_equal ka, a.generator_class
+    assert_equal kb, b.generator_class
+    assert_nil Croupier::Distribution.generator_class
+  end
+
+  def test_generator_block_setter_adds_generator_class
+    block = -> { 2 }
+    a = distribution_subclass_with_generator_block &block
+    assert_equal block, a.generator_block
+  end
+
+  def test_generator_block_sets_separated_blocks_for_each_subclass
+    pa = -> { 2 }
+    pb = -> { 3 }
+    a = distribution_subclass_with_generator_block &pa
+    b = distribution_subclass_with_generator_block &pb
+    assert_equal pa, a.generator_block
+    assert_equal pb, b.generator_block
+    assert_nil Croupier::Distribution.generator_block
+  end
+end

data/test/{test_distribution_class.rb → minitest/distribution_class/test_instance_methods.rb}

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestDistributionClass < MiniTest::Unit::TestCase
+class TestDistributionClassInstanceMethods < MiniTest::Unit::TestCase
 
   def test_distribution_has_name_and_description
     dist = Croupier::Distribution.new
@@ -8,10 +8,26 @@ class TestDistributionClass < MiniTest::Unit::TestCase
     assert_respond_to dist, 'description'
   end
 
+  def test_name_returns_distribution_name
+    dist = Class.new Croupier::Distribution do
+      distribution_name "Dist"
+    end
+    sample = dist.new
+    assert_equal "Dist", sample.name
+  end
+
+  def test_description_returns_distribution_description
+    dist = Class.new Croupier::Distribution do
+      distribution_description "Desc"
+    end
+    sample = dist.new
+    assert_equal "Desc", sample.description
+  end
+
   def test_distribution_accepts_parameter_configuration
     dist = Croupier::Distribution.new
     assert_equal dist.parameters, dist.default_parameters
-    dist.configure({:larry => 'bird', :leonard => 'euler'})
+    dist.configure({larry: 'bird', leonard: 'euler'})
     refute_equal dist.parameters, dist.default_parameters
     assert_equal dist.parameters[:larry], 'bird'
     assert_equal dist.parameters[:leonard], 'euler'
@@ -23,36 +39,18 @@ class TestDistributionClass < MiniTest::Unit::TestCase
   end
 
   def test_distribution_generates_array_of_n_results
-    a = Croupier::Distribution.new
-    def a.generate_number; 15; end
-    assert_equal a.generate_sample(15).size, 15
+    u = Croupier::Distributions.uniform
+    assert_equal u.generate_sample(15).size, 15
   end
 
-  def test_generate_number_calls_inv_cdf_if_present
+  def test_initialize_creates_a_generator
     c = Class.new(Croupier::Distribution) do
-      def inv_cdf n; true; end
-      def generate_sample n; false; end
-    end
-    a = c.new
-    assert a.generate_number
-  end
-
-  def test_generate_sample_calls_inv_cdf_if_present
-    c = Class.new(Croupier::Distribution) do
-      def inv_cdf n; true; end
-      def generate_number n; false; end
-    end
-    a = c.new
-    assert a.generate_sample(3).all?
-  end
-
-  def test_generate_number_not_returning_array_when_inv_cdf_not_implemented
-    c = Class.new(Croupier::Distribution) do
-      def generate_sample n
-        [1]*n
+      inv_cdf do |n|
+        2
       end
     end
-    a = c.new
-    assert_kind_of Numeric, a.generate_number
+
+    d = c.new
+    assert_kind_of ::Croupier::DistributionGenerators::InverseCDFGenerator, d.generator
   end
 end

data/test/minitest/distribution_generator_class/test_class_methods.rb

@@ -0,0 +1,24 @@
+require "minitest/autorun"
+require "croupier"
+
+class DistributionGeneratorClassClassMethods < MiniTest::Unit::TestCase
+
+  def create_generator_with_method_name name
+    Class.new Croupier::DistributionGenerator do
+      method_name name
+    end
+  end
+
+  def test_method_name_setter_sets_the_name
+    gen = create_generator_with_method_name "method_name"
+    assert_equal "method_name", gen.method_name
+  end
+
+  def test_method_name_sets_different_names_for_each_subclass
+    a = create_generator_with_method_name "method_a"
+    b = create_generator_with_method_name "method_b"
+    assert_equal "method_a", a.method_name
+    assert_equal "method_b", b.method_name
+    assert_nil Croupier::DistributionGenerator.method_name
+  end
+end

data/test/minitest/distribution_generator_class/test_instance_methods.rb

@@ -0,0 +1,35 @@
+require "minitest/autorun"
+require "croupier"
+
+class DistributionGeneratorClassIntanceMethods < MiniTest::Unit::TestCase
+
+  def setup
+    @distribution = Croupier::Distribution.new
+    @params = @distribution.parameters
+    @block = Proc.new { }
+    @generator = Croupier::DistributionGenerator.new @distribution, &@block
+    def @generator.generate_minimum_sample
+      [1,2,3]
+    end
+  end
+
+  def test_parameters_returns_distribution_parameters
+    assert_same @params, @generator.params
+  end
+
+  def test_distribution_accessor
+    assert_equal @distribution, @generator.distribution
+  end
+
+  def test_block_accessor
+    assert_equal @block, @generator.block
+  end
+
+  def test_croupier_method_returns_distributions
+    assert_same Croupier::Distributions, @generator.croupier
+  end
+
+  def test_to_enum
+    assert_equal [1,2,3,1,2], @generator.to_enum.take(5)
+  end
+end

data/test/minitest/distribution_generators/test_enumerator_block_generator.rb

@@ -0,0 +1,31 @@
+require "minitest/autorun"
+require "croupier"
+
+class TestEnumeratorBlockGenerator < MiniTest::Unit::TestCase
+
+  def setup
+    @klazz = Class.new(::Croupier::Distribution) do
+      def my_num
+        2
+      end
+    end
+    @distribution = @klazz.new
+    @block = ->(y) { y << my_num while true }
+    @gen = ::Croupier::DistributionGenerators::EnumeratorBlockGenerator.new @distribution, &@block
+  end
+
+  def test_initialize_calls_super_and_it_works
+    assert_equal @distribution, @gen.distribution
+    assert_equal @block, @gen.block
+  end
+
+  def test_to_enum_calls_the_block
+    assert_kind_of Enumerator, @gen.to_enum
+    assert_equal 2, @gen.to_enum.first
+  end
+
+  def test_block_can_access_methods_in_distribution
+    assert_kind_of Enumerator, @gen.to_enum
+    assert_equal 2, @gen.to_enum.first
+  end
+end

data/test/minitest/distribution_generators/test_enumerator_generator.rb

@@ -0,0 +1,33 @@
+require "minitest/autorun"
+require "croupier"
+
+class TestEnumeratorGenerator < MiniTest::Unit::TestCase
+
+  def setup
+    @klazz = Class.new(::Croupier::Distribution) do
+      def my_num
+        2
+      end
+    end
+    @distribution = @klazz.new
+    @block = ->(c) { Enumerator.new do |y| loop do y << [c, my_num]; end; end }
+    @gen = ::Croupier::DistributionGenerators::EnumeratorGenerator.new @distribution, &@block
+  end
+
+  def test_initialize_calls_super_and_it_works
+    assert_equal @distribution, @gen.distribution
+    assert_equal @block, @gen.block
+  end
+
+  def test_to_enum_calls_the_block
+    assert_kind_of Enumerator, @gen.to_enum
+    mod, num = @gen.to_enum.first
+    assert_equal 2, num
+    assert_equal ::Croupier::Distributions, mod
+  end
+
+  def test_block_can_access_methods_in_distribution
+    assert_kind_of Enumerator, @gen.to_enum
+    assert_equal 2, @gen.to_enum.first.last
+  end
+end

data/test/minitest/distribution_generators/test_inverse_cdf_generator.rb

@@ -0,0 +1,36 @@
+require "minitest/autorun"
+require "croupier"
+class TestInverseCdfGenerator < MiniTest::Unit::TestCase
+
+  def setup
+    @distribution = ::Croupier::Distribution.new
+    @block = ->(n) { 2+n }
+    @gen = ::Croupier::DistributionGenerators::InverseCDFGenerator.new @distribution, &@block
+  end
+
+  def test_initialize_calls_super_and_it_works
+    assert_equal @distribution, @gen.distribution
+    assert_equal @block, @gen.block
+  end
+
+  def test_to_enum_calls_the_block
+    @gen.to_enum.take(10).each do |n|
+      assert_operator 2, :<=, n, "#{n} is not at least 2"
+      assert_operator 3, :>, n, "#{n} is not strictly less than 3"
+    end
+  end
+
+  def test_block_can_access_methods_in_distribution
+    @distribution = Class.new(::Croupier::Distribution) do
+      def my_method n
+        2
+      end
+    end
+
+    @block = ->(n) { my_method n }
+
+    @gen = ::Croupier::DistributionGenerators::InverseCDFGenerator.new @distribution.new, &@block
+
+    assert_equal [2,2,2,2], @gen.to_enum.take(4).to_a
+  end
+end

data/test/minitest/distribution_generators/test_minimum_sample_generator.rb

@@ -0,0 +1,33 @@
+require "minitest/autorun"
+require "croupier"
+class TestMinimumSampleGenerator < MiniTest::Unit::TestCase
+
+  def setup
+    @distribution = ::Croupier::Distribution.new
+    @block = ->() { [1,2,3] }
+    @gen = ::Croupier::DistributionGenerators::MinimumSampleGenerator.new @distribution, &@block
+  end
+
+  def test_initialize_calls_super_and_it_works
+    assert_equal @distribution, @gen.distribution
+    assert_equal @block, @gen.block
+  end
+
+  def test_to_enum_calls_the_block
+    assert_equal [1,2,3,1,2,3,1], @gen.to_enum.take(7).to_a
+  end
+
+  def test_block_can_access_methods_in_distribution
+    @distribution = Class.new(::Croupier::Distribution) do
+      def my_method
+        [1,2,3]
+      end
+    end.new
+
+    @block = ->() { my_method }
+
+    @gen = ::Croupier::DistributionGenerators::MinimumSampleGenerator.new @distribution, &@block
+
+    assert_equal [1,2,3,1], @gen.to_enum.take(4).to_a
+  end
+end

data/test/minitest/distributions/test_bernoulli_distribution.rb

@@ -0,0 +1,13 @@
+require "minitest/autorun"
+require "croupier"
+class TestBinomialDistribution < MiniTest::Unit::TestCase
+
+  def bernoulli *args
+    ::Croupier::Distributions.bernoulli *args
+  end
+
+  def test_success_returns_correct_success
+    b = bernoulli success: 0.3
+    assert_in_delta 0.3, b.success, 1e-10, "success is not right"
+  end
+end

data/test/minitest/distributions/test_binomial_distribution.rb

@@ -0,0 +1,18 @@
+require "minitest/autorun"
+require "croupier"
+class TestBinomialDistribution < MiniTest::Unit::TestCase
+
+  def binomial *args
+    ::Croupier::Distributions.binomial *args
+  end
+
+  def test_success_returns_correct_success
+    b = binomial size: 15, success: 0.3
+    assert_in_delta 0.3, b.success, 1e-10, "success is not right"
+  end
+
+  def test_size_returns_correct_size
+    b = binomial size: 15, success: 0.3
+    assert_equal 15, b.size
+  end
+end

data/test/minitest/distributions/test_cauchy_distribution.rb

@@ -0,0 +1,18 @@
+require "minitest/autorun"
+require "croupier"
+class TestCauchyDistribution < MiniTest::Unit::TestCase
+
+  def cauchy *args
+    ::Croupier::Distributions.cauchy *args
+  end
+
+  def test_location_returns_correct_location
+    c = cauchy location: 3.1, scale: 5.2
+    assert_in_delta 3.1, c.location, 1e-10, "location is not right"
+  end
+
+  def test_scale_returns_correct_scale
+    c = cauchy location: 3.1, scale: 5.2
+    assert_in_delta 5.2, c.scale, 1e-10, "scale is not right"
+  end
+end

data/test/{distributions/minitest/test_credit_card.rb → minitest/distributions/test_credit_card_distribution.rb}

@@ -16,6 +16,11 @@ class TestDistributionClass < MiniTest::Unit::TestCase
     assert_respond_to dist, 'description'
   end
 
+  def test_init_method
+    c = Croupier::Distributions::CreditCard.new visa: true, initial_values: "5678"
+    assert_equal "45678", c.init
+  end
+
   def test_visa_starts_with_4
     assert_equal "4",  credit_card(visa: true)[0]
   end

data/test/{distributions/minitest → minitest/distributions}/test_degenerate_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestDistributionClass < MiniTest::Unit::TestCase
+class TestDegenerateDistribution < MiniTest::Unit::TestCase
 
   def test_distribution_has_name_and_description
     dist = Croupier::Distributions::Degenerate.new
@@ -18,6 +18,6 @@ class TestDistributionClass < MiniTest::Unit::TestCase
   def test_to_enum
     enum = Croupier::Distributions::Degenerate.new(constant: 5).to_enum
     assert_kind_of Enumerator, enum
-    assert_equal [5,5,5], enum.take(3)
+    assert_equal [5,5,5], enum.take(3).to_a
   end
 end

data/test/minitest/distributions/test_exponential_distribution.rb

@@ -0,0 +1,13 @@
+require "minitest/autorun"
+require "croupier"
+class TestExponentialDistribution < MiniTest::Unit::TestCase
+
+  def exponential *args
+    ::Croupier::Distributions.exponential *args
+  end
+
+  def test_lambda_returns_params_lambda
+    e = exponential lambda: 30.3
+    assert_in_delta 30.3, e.lambda, 1e-10, "lambda is not right"
+  end
+end

data/test/minitest/distributions/test_gamma_distribution.rb

@@ -0,0 +1,23 @@
+require "minitest/autorun"
+require "croupier"
+class TestGammaDistribution < MiniTest::Unit::TestCase
+
+  def gamma *args
+    ::Croupier::Distributions.gamma *args
+  end
+
+  def test_shape_returns_right_shape
+    g = gamma shape: 5.3, scale: 3.1
+    assert_in_delta 5.3, g.shape, 1e-10, "shape is not right"
+  end
+
+  def test_scale_returns_right_scale
+    g = gamma shape: 5.3, scale: 3.1
+    assert_in_delta 3.1, g.scale, 1e-10, "scale is not right"
+  end
+
+  def test_delta_is_correct_delta
+    g = gamma shape: 5.3, scale: 3.1
+    assert_in_delta 0.3, g.delta, 1e-10, "delta is not right"
+  end
+end

data/test/minitest/distributions/test_geometric_distribution.rb

@@ -0,0 +1,13 @@
+require "minitest/autorun"
+require "croupier"
+class TestGeometricDistribution < MiniTest::Unit::TestCase
+
+  def geometric *args
+    ::Croupier::Distributions.geometric *args
+  end
+
+  def test_success_returns_success_param
+    g = geometric success: 0.7
+    assert_in_delta 0.7, g.success, 1e-10, "success is right param"
+  end
+end

data/test/minitest/distributions/test_normal_distribution.rb

@@ -0,0 +1,17 @@
+require "minitest/autorun"
+require "croupier"
+class TestNormalDistribution < MiniTest::Unit::TestCase
+  def normal *args
+    ::Croupier::Distributions.normal *args
+  end
+
+  def test_mean_returns_mean
+    n = normal std: 1, mean: 23.2
+    assert_in_delta 23.2, n.mean, 1e-10, "mean is right"
+  end
+
+  def test_std_returns_standard_deviation
+    n = normal std: 1.23, mean: 2
+    assert_in_delta 1.23, n.std, 1e-10, "standard deviation is right"
+  end
+end

data/test/minitest/distributions/test_poisson_distribution.rb

@@ -0,0 +1,13 @@
+require "minitest/autorun"
+require "croupier"
+class TestPoissonDistribution < MiniTest::Unit::TestCase
+
+  def poisson *args
+    ::Croupier::Distributions.poisson *args
+  end
+
+  def test_lambda_gets_correct_value
+    p = poisson lambda: 10.1
+    assert_equal 10.1, p.lambda, "lambda is not right"
+  end
+end