croupier 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf6d755404722c636a61587f2381ca5ff96ff62b
-  data.tar.gz: 2229632adcaab36de7a98fd4d1d6bca922485a6d
+  metadata.gz: 3360595bc4f0222b501d7c3d420c8589050a7a7d
+  data.tar.gz: e9e3889ae3c87181b2dcd1552457ecd793ccb5ae
 SHA512:
-  metadata.gz: c03a5dcb2b26a88b3d6ccfb0bc205b72576ed9d4e802a10823ffca194ee291b8bbbe650870ba6a522e1c473fdee4216e64a1e6e7b78118366fa9f7182bd0a12f
-  data.tar.gz: 463e5689dc2fe99f689706925acfa1951689369617b9c4b58598f025e9e222661f79fd13f74976a3e3fff4c51b25053b767633703ca2c627e4639c00528fbab4
+  metadata.gz: 0da2b840c987376dd020441e08016582e2d0db6b34c41d064409b2a4777319ff3f7dd2861332f21fb73e85583cab9c9952f31085a9597d3c6fc99c318a2ce52a
+  data.tar.gz: 47fa3fc6a2426ac785ca207f2b296687b7fb111a206d8467ed8b9a575aa264056f462233788de785449aa519165e13676dc555e6e29ef63dcdd570419570bb91

data/README.md

@@ -9,7 +9,7 @@ Croupier generates random samples of numbers with specific probability distribut
 
 You need to have Ruby and Rubygems installed in your system. Then install croupier with:
 
-    $ gem install croupier
+    $ gem install croupier --pre
 
 ## Getting Started
 
@@ -29,8 +29,8 @@ where:
 
 ### Examples
 
-    $ croupier uniform 500                  # => 500 numbers with uniform distribution in [0,1] (default interval)
-    $ croupier uniform 125 -min 7 -max 15   # => 125 numbers with uniform distribution in [7,15]
+    $ croupier uniform 500                  # => 500 numbers with uniform distribution in [0,1) (default interval)
+    $ croupier uniform 125 --included 15 --excluded 7   # => 125 numbers with uniform distribution in (7,15]
     $ croupier exponential 1000 -lambda 1.3 # => 1000 numbers following an exponential distribution with rate 1.3
 
 ### Available distributions and options
@@ -40,6 +40,7 @@ Current version implements the following distributions:
 * Bernoulli
 * Binomial
 * Cauchy
+* Credit Card
 * Degenerate
 * Exponential
 * Gamma
@@ -66,38 +67,36 @@ First of all require the croupier library:
 
     require 'croupier'
 
-And then use the the distribution you want to generate the sample. You can get just one number (using ```.generate_number```) or an array of any given size (using ```.generate_sample(N)```)
+And then use the the distribution you want to generate the sample. Since version 2.0, all ```Croupier::Distribution```s
+are ```Enumerable```s, and the ```.generate_number``` and ```.generate_sample(n)``` methods are now deprecated.
+ ```first``` and ```take(n)``` can be used instead.
 
-    dist = Croupier::Distributions::Exponential.new(:lambda => 1.7)
-    dist.generate_sample(100) #=> returns an array of 100 random numbers following an exponential with rate 1.7
-    dist.generate_number #=> returns one random number following an exponential with rate 1.7
+    dist = Croupier::Distributions.exponential(lambda: 1.7)
+    dist.take(100) #=> returns an array of 100 random numbers following an exponential with rate 1.7
+    dist.first #=> returns one random number following an exponential with rate 1.7
 
-It's posible to instantiate each Distribution class directly:
+Though it's posible to instantiate each Distribution class directly:
 
-    dist = Croupier::Distributions::Exponential.new(:lambda => 1.7)
+    dist = Croupier::Distributions::Exponential.new(lambda: 1.7)
 
-or calling Distributions methods:
+calling methods on ```Croupier::Distributions``` (note the final s) module is recommended:
 
-    dist = Croupier::Distributions.exponential :lambda => 1.7
+    dist = Croupier::Distributions.exponential lambda: 1.7
 
-To get a list of all available distributions/methods in Distributions module call ```list```
+To get a list of all available distributions/methods in ```Distributions``` module call ```list```
 
     Croupier::Distributions.list
 
-Distributions have a ```to_enum``` method that return an (infinity) enumerator, so you
-can use any Enumerable method on it:
+Distributions' Enumerable behaviour comes from an infinite ```Enumerator::Lazy```. Take this into account
+when calling ```Enumerable``` methods.
 
-    dist = Croupier::Distributions.exponential(:lambda => 17).to_enum
+    dist = Croupier::Distributions.exponential(lambda: 17)
     dist.each_slice(2).take(3)
     => [[0.7455570432863594, 1.6543154039789472], [4.261950709816685, 0.2860058032480469], [1.4761279576207826, 0.6433699882662834]]
 
 ## How to generate a new distribution.
 
-There are several ways. The easiest one is to override ```generate_number``` or ```generate_sample``` (one is enough).
-
-Nonetheless there is another cool way to implement a distribution: implementing ```inv_cdf```:
-
-```ìnv_cdf``` receives a parameter ```n``` that is a sample of a uniform distribution. It should return the inverse of the cdf applied to ```n```.
+ TO BE COMPLETED WHEN API IS FINISHED.
 
 ## License
 

data/RUNNING_TESTS.md

@@ -12,7 +12,14 @@ You can run these tests using the default Rake task:
 
     $ rake
 
-### R tests
+### R tests (automagic)
+
+Make sure you have downloaded all git submodules first since R tests are now a
+dependency. From the 2.0 release, validating the distributions is as simple as running:
+
+    > rake test:distributions
+
+### R tests (manual steps)
 
 There's a group of tests validating the probability distribution of several samples of numbers generated with Croupier.
 To generate samples to be tested, run the script ```generate_test_data.sh```:
@@ -35,13 +42,13 @@ Other R packages needed:
     * vcd
 
 The test script will try to install all dependencies if they are not found in your R installation.
-You can run the test/testsuite.R file:
+You can run the test/rtests.R file:
 
 Using Rscript:
 
-    $ Rscript testsuite.R
+    $ Rscript rtests.R
 
 or from the R console:
 
-    source('testsuite.R')
+    source('rtests.R')
 

data/lib/croupier.rb

@@ -99,5 +99,30 @@ module Croupier
     def seed
       random.seed
     end
+
+    # Croupier Warn
+    #
+    # @param *args [String[,String...]] messages
+    # @return NilClass
+    def warn *args
+      if @warn
+        args.each {|m| message m }
+      end
+    end
+
+    # Activates warning messages (activated by default)
+    def activate_warnings
+      @warn = true
+    end
+
+    # Deactivates warning messages
+    def deactivate_warnings
+      @warn = false
+    end
+
+    def warn?
+      @warn = true if @warn.nil?
+      @warn
+    end
   end
 end

data/lib/croupier/cli/application.rb

@@ -27,7 +27,7 @@ module Croupier
       def run
         Croupier.trap_interrupt
         distribution, sample_size, params = parse_distribution_options
-        distribution.new(params).generate_sample(sample_size).each{|n| Croupier.message n}
+        distribution.new(params).take(sample_size).each{|n| Croupier.message n}
       end
 
       private

data/lib/croupier/distribution.rb

@@ -62,11 +62,36 @@ module Croupier
       # @param options [Hash] new cli options
       # return [Hash] current cli options
       def cli_options options=nil
-        @cli_options = options if options
-        @cli_options || {}
+        if options
+          cli_banner options[:banner] if options[:banner]
+          (options[:options] || []).each do |opt|
+            cli_option *opt
+          end
+        end
+        @cli_options ||= {}
       end
 
-      # Sets the cli_name if given
+      # Adds an option to the :options Array in cli_options hash.
+      #
+      # @param option [Symbol] new cli option
+      # @param description [String] description of the cli option
+      # @param params [Hash] option params for the cli option
+      # return [Array] current cli options
+      def cli_option option, description, params
+        cli_options[:options] ||= []
+        define_method_for_option option, params[:type]
+        cli_options[:options] << [option, description, params]
+      end
+
+      # Sets the value for the :banner key in cli_options hash.
+      #
+      # @param banner [String] new cli banner
+      # return [String] current cli banner
+      def cli_banner banner
+        cli_options[:banner] = banner
+      end
+
+      # Sets the cli_name if given.
       #
       # @param cli_name [String] new cli name
       # @return [String] current cli name
@@ -75,6 +100,23 @@ module Croupier
         @cli_name
       end
 
+      # Adds an adjustment. And adjustment is the
+      # block that will go through a map after the
+      # enumerator is created.
+      #
+      # @param [Proc] block for the map.
+      # @returns [Array] procs
+      def adjust &block
+        adjustments << block
+      end
+
+      # Returns current adjustments.
+      #
+      # @returns [Array] array of procs.
+      def adjustments
+        @adjustment ||= []
+      end
+
       def default_parameters
         Hash[(cli_options[:options]||{}).map do |name, desc, hash|
           [name,hash[:default]]
@@ -91,6 +133,14 @@ module Croupier
       def respond_to?(method, include_private = false) # :nodoc:
         ::Croupier::DistributionGenerators.list.include?(method.to_s) || super(method, include_private)
       end
+
+      protected
+      def define_method_for_option name, type=:float
+        name = :"#{name}?" if type == :boolean
+        self.send :define_method, name do
+          self.params[name.to_sym]
+        end
+      end
     end
 
     # Initializes Distribution object and adds received options to the distribution parameters.
@@ -135,21 +185,40 @@ module Croupier
     end
 
     # Make Croupier::Distribution an Enumerable
-    include Enumerable
+    # Read the tests for the instance methods.
+    # Then, cry.
+    Enumerable.instance_methods.each do |method|
+      self.send(:define_method, method) do |*args, &block|
+        self.to_enum.send(method, *args, &block)
+      end
+    end
 
     def each &block
       if block_given?
-        self.to_enum.each &block
+        to_enum.each &block
       else
-        self.to_enum.each
+        to_enum.each
       end
     end
 
+    def take n
+      to_enum.take(n).to_a
+    end
+
     def to_enum
-      @enum ||= @generator.to_enum.lazy
+      @enum ||= apply_adjustments(@generator.to_enum.lazy)
     end
 
     protected
+
+    def apply_adjustments enum
+      self.class.adjustments.inject(enum) do |enum, adj|
+        enum.map do |n|
+          self.instance_exec(n, &adj)
+        end
+      end
+    end
+
     def create_generator
       if self.class.generator_class && self.class.generator_block
         @generator = self.class.generator_class.new self, &self.class.generator_block

data/lib/croupier/distributions/bernoulli.rb

@@ -13,25 +13,19 @@ module Croupier
 
       cli_name "bernoulli"
 
-      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."
-      })
+      cli_option :success, 'success probability', {type: :float, short: "-p", default: 0.5}
+
+      cli_banner "Bernoulli distribution. Discrete probability distribution taking value 1 with success probability p and value 0 with failure probability 1-p."
+
 
       enumerator do |c|
-        c.binomial(success: success, size: 1).to_enum.lazy
+        c.binomial(success: success, size: 1).to_enum
       end
 
       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 success
-        params[:success]
-      end
     end
   end
 end

data/lib/croupier/distributions/binomial.rb

@@ -14,13 +14,11 @@ module Croupier
 
       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."
-      })
+      cli_option :size, 'number of trials', {type: :integer, default: 1}
+      cli_option :success, 'success probability of each trial', {type: :float, short: "-p", default: 0.5}
+
+      cli_banner "Binomial distribution. Discrete probability distribution of the number of successes in a sequence of Bernoulli trials."
+
 
       enumerator_block do |y|
         g = ::Croupier::Distributions.geometric(success: success).to_enum.lazy
@@ -40,15 +38,6 @@ module Croupier
         super(options)
         raise Croupier::InputParamsError, "Probability of success must be in the interval [0,1]" if params[:success] > 1 || params[:success] < 0
       end
-
-      def size
-        params[:size]
-      end
-
-      def success
-        params[:success]
-      end
-
     end
   end
 end

data/lib/croupier/distributions/cauchy.rb

@@ -13,13 +13,10 @@ module Croupier
 
       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"
-      })
+      cli_option :location, 'location param', {type: :float, default:0.0}
+      cli_option :scale, 'scale param', {type: :float, default: 1.0}
+
+      cli_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)))
@@ -29,14 +26,6 @@ module Croupier
         super(options)
         raise Croupier::InputParamsError, "Invalid scale value, it must be positive" unless params[:scale] > 0
       end
-
-      def location
-        params[:location]
-      end
-
-      def scale
-        params[:scale]
-      end
     end
   end
 end

data/lib/croupier/distributions/credit_card.rb

@@ -13,34 +13,35 @@ module Croupier
 
       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"
-      })
+      cli_option :master_card, 'master card type', {type: :boolean, default: false}
+      cli_option :american_express, 'american express card type', {type: :boolean, default: false}
+      cli_option :visa, 'visa card type', {type: :boolean, default: false}
+      cli_option :discover, 'discover card type', {type: :boolean, default: false}
+      cli_option :initial_values, 'initial values for the credit card. They will be placed after card type if one is given.', {type: :string, default: ""}
+
+      cli_banner "Credit Card distribution. Generate random card numbers"
 
       # Returns a lambda that completes
       # the credit card number up to
       # 15 numbers.
-      def fill_number
+      def self.fill_number
         ->(n) { "#{n}#{generate_random_string(15-n.size)}"[0..14] }
       end
 
       # Returns a lambda that adds
       # the checksum number
-      def add_checksum
+      def self.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)
+        c.degenerate(constant: init)
       end
 
+      adjust &fill_number
+
+      adjust &add_checksum
+
       def initialize(options={})
         super(options)
       end

data/lib/croupier/distributions/degenerate.rb

@@ -12,16 +12,13 @@ module Croupier
 
       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."
-       })
+      cli_option :constant, 'value to be returned', {type: :float, default: 42.0}
+
+      cli_banner "Degenerate distribution. Discrete probability distribution that returns the same value each time."
 
       enumerator_block do |y|
         loop do
-          y << params[:constant]
+          y << constant
         end
       end
 

data/lib/croupier/distributions/exponential.rb

@@ -14,12 +14,9 @@ module Croupier
 
       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"
-      })
+      cli_option :lambda, 'rate param', {type: :float, default: 1.0}
+
+      cli_banner "Exponential distribution. Generate numbers following a exponential distribution for a given lambda rate"
 
       inv_cdf do |n|
         (-1 / lambda) * Math.log(1 - n)
@@ -29,10 +26,6 @@ module Croupier
         super(options)
         raise Croupier::InputParamsError, "lambda cannot be negative" if params[:lambda] <= 0
       end
-
-      def lambda
-        params[:lambda]
-      end
     end
   end
 end

data/lib/croupier/distributions/gamma.rb

@@ -13,30 +13,21 @@ module Croupier
 
       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."
-      })
+      cli_option :shape, 'shape of the distribution', {type: :float, default: 1.0}
+      cli_option :scale, 'scale of the distribution', {type: :float, default: 1.0}
 
-      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
+      cli_banner "Family of continuous distributions with two parameters, shape and scale."
 
-      def initialize(options={})
-        super(options)
+      enumerator do |c|
+        c.degenerate(constant: scale).zip(xi_enum, adjust_enum)
       end
 
-      def shape
-        params[:shape]
+      adjust do |scale, xi, adj|
+        scale * (xi - adj)
       end
 
-      def scale
-        params[:scale]
+      def initialize(options={})
+        super(options)
       end
 
       def delta

data/lib/croupier/distributions/geometric.rb

@@ -18,12 +18,9 @@ module Croupier
 
       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, ...} }"
-      })
+      cli_option :success, 'success probability of each trial', {type: :float, short: "-p", default: 0.5}
+
+      cli_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.
@@ -35,10 +32,6 @@ module Croupier
         super(options)
         raise Croupier::InputParamsError, "Probability of success must be in the interval [0,1]" if params[:success] > 1 || params[:success] < 0
       end
-
-      def success
-        params[:success]
-      end
     end
   end
 end

data/lib/croupier/distributions/nbinomial.rb

@@ -16,16 +16,12 @@ module Croupier
 
       cli_name "nbinomial"
 
-      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."
-      })
+      cli_option :size, 'number of errors', {type: :integer, default: 1}
+      cli_option :success, 'success probability of each trial', {type: :float, short: "-p", default: 0.5}
+      cli_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|
+        c.geometric(success: success).each_slice(size).map do |x|
           x.inject(-size,&:+)
         end
       end
@@ -34,14 +30,6 @@ module Croupier
         super(options)
         raise Croupier::InputParamsError, "Probability of success must be in the interval [0,1]" if params[:success] > 1 || params[:success] < 0
       end
-
-      def success
-        params[:success]
-      end
-
-      def size
-        params[:size]
-      end
     end
   end
 end

data/lib/croupier/distributions/normal.rb

@@ -14,13 +14,10 @@ module Croupier
 
       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."
-      })
+      cli_option :mean, 'mean of the distribution', {type: :float, default: 0.0}
+      cli_option :std, 'standard deviation of the distribution', {type: :float, default: 1.0}
+
+      cli_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
@@ -30,22 +27,18 @@ module Croupier
         ]
       end
 
-      def initialize(options={})
-        super(options)
+      # Adjust std
+      adjust do |n|
+        n * std
       end
 
-      def std
-        params[:std]
+      # Adjust mean
+      adjust do |n|
+        n + mean
       end
 
-      def mean
-        params[:mean]
-      end
-
-      def to_enum
-        @generator.to_enum.
-          map {|x| x * std}.  # Adjust standard deviation
-          map {|x| x + mean}  # Adjust mean
+      def initialize(options={})
+        super(options)
       end
     end
   end

data/lib/croupier/distributions/poisson.rb

@@ -17,12 +17,9 @@ module Croupier
 
       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."
-      })
+      cli_option :lambda, 'rate parameter (equal to the mean of the distribution)', {type: :integer, default: 50}
+
+      cli_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)
@@ -39,10 +36,6 @@ module Croupier
       def initialize(options={})
         super(options)
       end
-
-      def lambda
-        params[:lambda]
-      end
     end
   end
 end

data/lib/croupier/distributions/triangular.rb

@@ -13,14 +13,11 @@ module Croupier
 
       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."
-      })
+      cli_option :lower, 'lower limit', {type: :float, short: '-a', default: 0.0}
+      cli_option :upper, 'upper limit', {type: :float, short: '-b', default: 1.0}
+      cli_option :mode, 'mode', {type: :float, short: '-c', default: 0.5}
+
+      cli_banner "Triangular distribution. Continuous distribution whose support is the interval (a,b), with mode c."
 
       inv_cdf do |n|
         if n < @F_c
@@ -33,28 +30,16 @@ module Croupier
       def initialize(options={})
         super(options)
         if params[:lower] >= params[:upper]
-          warn("Lower limit is greater than upper limit. Changing their values.")
+          ::Croupier.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.")
+          ::Croupier.warn("Mode is not in the support. Mode value will be change to median.")
           params[:mode] = (params[:lower]+params[:upper])/2.0;
         end
         @F_c = (params[:mode]-params[:lower]).to_f/(params[:upper]-params[:lower])
       end
 
-      def lower
-        params[:lower]
-      end
-
-      def upper
-        params[:upper]
-      end
-
-      def mode
-        params[:mode]
-      end
-
       def range
         @range ||= upper - lower
       end

data/lib/croupier/distributions/uniform.rb

@@ -14,13 +14,24 @@ module Croupier
 
       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."
-      })
+      cli_option :included, 'interval included value', {type: :float, short: "-i", default: 0.0}
+      cli_option :excluded, 'interval excluded value', {type: :float, short: "-e", default: 1.0}
+
+      cli_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."
+
+      enumerator_block do |y|
+        loop do
+          y << ::Croupier.rand
+        end
+      end
+
+      adjust do |n|
+        exclude_value.(n)
+      end
+
+      adjust do |n|
+        min + range * n
+      end
 
       def initialize(options={})
         super options
@@ -40,24 +51,7 @@ module Croupier
       attr_reader :exclude_value, :min, :max, :range
 
       def inverted?
-        params[:included] > params[:excluded]
-      end
-
-      def to_enum
-        @enum ||= base_enum.lazy.
-            map(&exclude_value).
-            map do |n|
-              min + range * n
-            end
-      end
-
-      protected
-      def base_enum
-        Enumerator.new do |y|
-          loop do
-            y << Croupier.rand
-          end
-        end
+        included > excluded
       end
     end
   end

data/lib/croupier/version.rb

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

data/test/minitest/distribution_class/test_class_methods.rb

@@ -1,7 +1,11 @@
-require 'minitest/autorun'
-require 'croupier'
+require "minitest/autorun"
+require "croupier"
 
-class TestDistributionClassClassMethods < MiniTest::Unit::TestCase
+class TestDistributionClassClassMethods < Minitest::Test
+
+  def distribution_subclass
+    Class.new ::Croupier::Distribution
+  end
 
   def distribution_subclass_with_name name
     Class.new Croupier::Distribution do
@@ -33,6 +37,12 @@ class TestDistributionClassClassMethods < MiniTest::Unit::TestCase
     end
   end
 
+  def distribution_subclass_with_cli_banner banner
+    Class.new Croupier::Distribution do
+      cli_banner banner
+    end
+  end
+
   def distribution_subclass_with_cli_name name
     Class.new Croupier::Distribution do
       cli_name name
@@ -78,6 +88,65 @@ class TestDistributionClassClassMethods < MiniTest::Unit::TestCase
     assert_nil Croupier::Distribution.cli_name
   end
 
+  def test_cli_banner_setter_adds_the_cli_banner
+    a = distribution_subclass_with_cli_banner "Instructions for use of this Distribution"
+    assert_equal "Instructions for use of this Distribution", a.cli_options[:banner]
+  end
+
+  def test_cli_banner_sets_separated_banners_for_each_subclass
+    a = distribution_subclass_with_cli_banner "a"
+    b = distribution_subclass_with_cli_banner "b"
+    assert_equal "a", a.cli_options[:banner]
+    assert_equal "b", b.cli_options[:banner]
+    assert_nil Croupier::Distribution.cli_options[:banner]
+  end
+
+  def test_cli_option_setter_adds_a_cli_option
+    option = [:abc, "prints ABC", {}]
+    a = distribution_subclass_with_name "Test"
+    a.cli_option option[0], option[1], option[2]
+    assert_equal [option], a.cli_options[:options]
+  end
+
+  def test_cli_option_does_not_delete_previous_cli_options
+    opts = {banner: 'Hey', options: [[:a, "A", {type: :boolean}], [:b, "B", {type: :float}]]}
+    option  = [:abc, "prints ABC", {}]
+    a = distribution_subclass_with_cli_options opts
+    a.cli_option option[0], option[1], option[2]
+    assert_equal (opts[:options] << option), a.cli_options[:options]
+  end
+
+  def test_cli_option_adds_separated_option_for_each_subclass
+    optionA = [:abc, "prints ABC", {}]
+    optionB = [:xyz, "prints XYZ", {type: :boolean}]
+    a = distribution_subclass_with_name "A"
+    b = distribution_subclass_with_name "B"
+    a.cli_option optionA[0], optionA[1], optionA[2]
+    b.cli_option optionB[0], optionB[1], optionB[2]
+    assert_equal [optionA], a.cli_options[:options]
+    assert_equal [optionB], b.cli_options[:options]
+    assert_empty Croupier::Distribution.cli_options
+  end
+
+  def test_cli_option_adds_instance_method
+    a = distribution_subclass_with_name "A"
+    a.cli_option :cowabunga, "TMNT", {type: :float}
+    assert_respond_to a.new, :cowabunga
+  end
+
+  def test_cli_options_adds_instance_method_with_modified_name
+    a = distribution_subclass_with_name "A"
+    a.cli_option :are_you_my_mummy, "Doctor Who", {type: :boolean}
+    assert_respond_to a.new, :are_you_my_mummy?
+  end
+
+  def test_cli_option_defines_an_accessor
+    a = distribution_subclass_with_name "A"
+    a.cli_option :cowabunga, "TMNT", {type: :float}
+    instance = a.new cowabunga: 1.3
+    assert_equal 1.3, instance.cowabunga
+  end
+
   def test_cli_options_setter_adds_the_options
     opts = Hash.new
     a = distribution_subclass_with_cli_options opts
@@ -139,4 +208,49 @@ class TestDistributionClassClassMethods < MiniTest::Unit::TestCase
     assert_equal pb, b.generator_block
     assert_nil Croupier::Distribution.generator_block
   end
+
+  def test_adjustments_is_empty_at_first
+    a = distribution_subclass
+    assert_empty a.adjustments, "Adjustments are not empty"
+  end
+
+  def test_adjustment_add_proc_to_adjustments_in_order
+    a = distribution_subclass
+    proc1 = -> { 1 }
+    proc2 = -> { 2 }
+    a.adjust &proc1
+    a.adjust &proc2
+    assert_equal 2, a.adjustments.length
+    assert_equal proc1, a.adjustments.first
+    assert_equal proc2, a.adjustments.last
+  end
+
+  def test_adjustment_adds_separated_adjustment_for_different_subclasses
+    a = distribution_subclass
+    a.adjust do |x| 1 end
+    b = distribution_subclass
+    b.adjust do |x| 2 end
+
+    assert a.adjustments != b.adjustments
+    assert_empty distribution_subclass.adjustments
+  end
+
+  def test_adjustments_are_called_in_order
+    a = distribution_subclass
+    a.enumerator_block do |y|
+      num = 0
+      loop do
+        num += 1; y << num
+      end
+    end
+    a.adjust do |n|
+      n + 3
+    end
+
+    a.adjust do |n|
+      n * 2
+    end
+
+    assert_equal [8, 10, 12], a.new.take(3)
+  end
 end

data/test/minitest/distribution_class/test_instance_methods.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestDistributionClassInstanceMethods < MiniTest::Unit::TestCase
+class TestDistributionClassInstanceMethods < Minitest::Test
 
   def test_distribution_has_name_and_description
     dist = Croupier::Distribution.new
@@ -53,4 +53,22 @@ class TestDistributionClassInstanceMethods < MiniTest::Unit::TestCase
     d = c.new
     assert_kind_of ::Croupier::DistributionGenerators::InverseCDFGenerator, d.generator
   end
+
+  # What The Fuck
+  # Making ::Croupier::Distribution a subclass of Enumerator::Lazy
+  # is a fucking hell. Impossible, as far as I am concerned.
+  # Yes, I can say fucking since trying to do so made MRI to break
+  # and cry like Captain Hammer at the end of Dr. Horrible.
+  # If Enumerable gets just included, we lose the lazy part.
+  #
+  # My solution, bang my head against the train window and then
+  # delegate all the methods to the enum.
+  def test_distribution_is_enumerable
+    dist = ::Croupier::Distribution.new
+
+    assert_respond_to dist, :each, "distribution does not respond to each"
+    Enumerable.instance_methods.each do |method|
+      assert_respond_to dist, method, "distribution does not respond to #{method}"
+    end
+  end
 end

data/test/minitest/distribution_generator_class/test_class_methods.rb

@@ -1,7 +1,7 @@
 require "minitest/autorun"
 require "croupier"
 
-class DistributionGeneratorClassClassMethods < MiniTest::Unit::TestCase
+class DistributionGeneratorClassClassMethods < Minitest::Test
 
   def create_generator_with_method_name name
     Class.new Croupier::DistributionGenerator do

data/test/minitest/distribution_generator_class/test_instance_methods.rb

@@ -1,7 +1,7 @@
 require "minitest/autorun"
 require "croupier"
 
-class DistributionGeneratorClassIntanceMethods < MiniTest::Unit::TestCase
+class DistributionGeneratorClassIntanceMethods < Minitest::Test
 
   def setup
     @distribution = Croupier::Distribution.new

data/test/minitest/distribution_generators/test_enumerator_block_generator.rb

@@ -1,7 +1,7 @@
 require "minitest/autorun"
 require "croupier"
 
-class TestEnumeratorBlockGenerator < MiniTest::Unit::TestCase
+class TestEnumeratorBlockGenerator < Minitest::Test
 
   def setup
     @klazz = Class.new(::Croupier::Distribution) do

data/test/minitest/distribution_generators/test_enumerator_generator.rb

@@ -1,7 +1,7 @@
 require "minitest/autorun"
 require "croupier"
 
-class TestEnumeratorGenerator < MiniTest::Unit::TestCase
+class TestEnumeratorGenerator < Minitest::Test
 
   def setup
     @klazz = Class.new(::Croupier::Distribution) do

data/test/minitest/distribution_generators/test_inverse_cdf_generator.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestInverseCdfGenerator < MiniTest::Unit::TestCase
+class TestInverseCdfGenerator < Minitest::Test
 
   def setup
     @distribution = ::Croupier::Distribution.new

data/test/minitest/distribution_generators/test_minimum_sample_generator.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestMinimumSampleGenerator < MiniTest::Unit::TestCase
+class TestMinimumSampleGenerator < Minitest::Test
 
   def setup
     @distribution = ::Croupier::Distribution.new

data/test/minitest/distributions/test_bernoulli_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestBinomialDistribution < MiniTest::Unit::TestCase
+class TestBinomialDistribution < Minitest::Test
 
   def bernoulli *args
     ::Croupier::Distributions.bernoulli *args

data/test/minitest/distributions/test_binomial_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestBinomialDistribution < MiniTest::Unit::TestCase
+class TestBinomialDistribution < Minitest::Test
 
   def binomial *args
     ::Croupier::Distributions.binomial *args

data/test/minitest/distributions/test_cauchy_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestCauchyDistribution < MiniTest::Unit::TestCase
+class TestCauchyDistribution < Minitest::Test
 
   def cauchy *args
     ::Croupier::Distributions.cauchy *args

data/test/minitest/distributions/test_credit_card_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestDistributionClass < MiniTest::Unit::TestCase
+class TestDistributionClass < Minitest::Test
 
   def valid_options(optional={})
     {}.merge(optional)

data/test/minitest/distributions/test_degenerate_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestDegenerateDistribution < MiniTest::Unit::TestCase
+class TestDegenerateDistribution < Minitest::Test
 
   def test_distribution_has_name_and_description
     dist = Croupier::Distributions::Degenerate.new
@@ -8,6 +8,11 @@ class TestDegenerateDistribution < MiniTest::Unit::TestCase
     assert_respond_to dist, 'description'
   end
 
+  def test_constant_returns_current_distribution_constant
+    dist = Croupier::Distributions::Degenerate.new constant: "Macarena"
+    assert_equal "Macarena", dist.constant
+  end
+
   def test_returns_only_one_value
     dist = Croupier::Distributions::Degenerate.new constant: 5.34
     5.times do

data/test/minitest/distributions/test_exponential_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestExponentialDistribution < MiniTest::Unit::TestCase
+class TestExponentialDistribution < Minitest::Test
 
   def exponential *args
     ::Croupier::Distributions.exponential *args

data/test/minitest/distributions/test_gamma_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestGammaDistribution < MiniTest::Unit::TestCase
+class TestGammaDistribution < Minitest::Test
 
   def gamma *args
     ::Croupier::Distributions.gamma *args

data/test/minitest/distributions/test_geometric_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestGeometricDistribution < MiniTest::Unit::TestCase
+class TestGeometricDistribution < Minitest::Test
 
   def geometric *args
     ::Croupier::Distributions.geometric *args

data/test/minitest/distributions/test_normal_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestNormalDistribution < MiniTest::Unit::TestCase
+class TestNormalDistribution < Minitest::Test
   def normal *args
     ::Croupier::Distributions.normal *args
   end

data/test/minitest/distributions/test_poisson_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestPoissonDistribution < MiniTest::Unit::TestCase
+class TestPoissonDistribution < Minitest::Test
 
   def poisson *args
     ::Croupier::Distributions.poisson *args

data/test/minitest/distributions/test_triangular_distribution.rb

@@ -1,11 +1,19 @@
 require "minitest/autorun"
 require "croupier"
-class TestTriangularDistribution < MiniTest::Unit::TestCase
+class TestTriangularDistribution < Minitest::Test
 
   def triangular(opts={})
     ::Croupier::Distributions.triangular(opts)
   end
 
+  def setup
+    ::Croupier.deactivate_warnings
+  end
+
+  def teardown
+    ::Croupier.activate_warnings
+  end
+
   def test_change_lower_and_upper_values_if_they_are_not_in_the_right_order
     t = triangular lower: 8, upper: 3, mode: 4
     assert_equal 3, t.lower, "lower is not 3"

data/test/minitest/distributions/test_uniform_distribution.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestUniformDistribution < MiniTest::Unit::TestCase
+class TestUniformDistribution < Minitest::Test
 
   def uniform(opts={})
     ::Croupier::Distributions.uniform(opts)

data/test/minitest/test_croupier_module.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestCroupierModule < MiniTest::Unit::TestCase
+class TestCroupierModule < Minitest::Test
 
   def test_module_manages_a_croupier_cli_application_object
     app = Croupier.application
@@ -12,5 +12,4 @@ class TestCroupierModule < MiniTest::Unit::TestCase
     Croupier.application = app
     assert Croupier.application == app
   end
-
 end

data/test/minitest/test_distribution_generators_module.rb

@@ -1,7 +1,7 @@
 require "minitest/autorun"
 require "croupier"
 
-class TestDistributionGeneratorsModule < MiniTest::Unit::TestCase
+class TestDistributionGeneratorsModule < Minitest::Test
 
   def test_list_of_all_distribution_generators
     all = Croupier::DistributionGenerators.all
@@ -27,7 +27,7 @@ class TestDistributionGeneratorsModule < MiniTest::Unit::TestCase
       assert_includes list, d.method_name, "#{d.method_name} not included in list"
     }
   end
-  
+
   def test_all_and_list_have_same_size
     all = Croupier::DistributionGenerators.all
     list = Croupier::DistributionGenerators.list

data/test/minitest/test_distributions_module.rb

@@ -1,6 +1,6 @@
 require "minitest/autorun"
 require "croupier"
-class TestDistributionsModule < MiniTest::Unit::TestCase
+class TestDistributionsModule < Minitest::Test
 
   def test_list_of_all_distributions
     all = Croupier::Distributions.all
@@ -25,13 +25,13 @@ class TestDistributionsModule < MiniTest::Unit::TestCase
       assert list.include?(d.cli_name), "#{d.cli_name} not included in list"
     }
   end
-  
+
   def test_all_and_list_have_same_size
     all = Croupier::Distributions.all
     list = Croupier::Distributions.list
     assert list.size == all.size
   end
-  
+
   def test_dynamic_distribution_methods
     Croupier::Distributions.list.each{|method|
       assert Croupier::Distributions.respond_to?(method), "No response for #{method} method"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: croupier
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc1
+  version: 2.0.0.rc2
 platform: ruby
 authors:
 - Juanjo Bazán
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-24 00:00:00.000000000 Z
+date: 2013-10-22 00:00:00.000000000 Z
 dependencies: []
 description: Croupier is a Ruby gem to generate a random sample of numbers with a
   given probability distribution.