cross_entropy 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04a027fd6b1ff464e5845bd8a85657fda3cef628
-  data.tar.gz: 1e542c3df5f6a36d2f13c564c3dfcb46d5e2d69f
+  metadata.gz: 64569dfb8741ff5fae2bb7ed5176b273e8a3ba34
+  data.tar.gz: a8b475c6a7898d692c0ce984ef41a3f2187e11e5
 SHA512:
-  metadata.gz: 040644e34aed5dbe019789af16ba95226ac4e9c09e8be119d76aff5cf5d30946b286cfe0cdd7c700356217389c4b90060fcb564856e3f618a20fff6830e7fca6
-  data.tar.gz: a57a8845f9e8e3e56bc1c91ccda84bb6961d861fb69ef7f1c8c1b4518e3561b7fcdeb8ff410a19905b4971eba4f9a84a1fcc01d66f8d62896b7e55cca2a11e16
+  metadata.gz: f1231183cdac6d29c90708d0781465aeee2ac996f02075026610b8f781a2241c41a2edb71010b2944b5e65b8493dd4c120f6db328d46f9c4cdfbb067e8cc70bc
+  data.tar.gz: bf1737897c3e6afc7e36d3bd90c0ce2273b9beb3da6ddc0f39f1308ac58aa5c5e207b820b49e3d0411af3580847dcdb5c0eefbd593543da3e6e8951ff2258573

data/README.md

@@ -1,8 +1,9 @@
 # cross_entropy
 
 [![Build Status](https://travis-ci.org/jdleesmiller/cross_entropy.svg?branch=master)](https://travis-ci.org/jdleesmiller/cross_entropy)
+[![Gem Version](https://badge.fury.io/rb/cross_entropy.svg)](https://badge.fury.io/rb/cross_entropy)
 
-https://github.com/jdleesmiller/cross_entropy 
+https://github.com/jdleesmiller/cross_entropy
 
 ## SYNOPSIS
 
@@ -10,12 +11,12 @@ Implementations of the [Cross Entropy Method](https://en.wikipedia.org/wiki/Cros
 
 ### What is the Cross Entropy method?
 
-It's basically like a [genetic algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm) without the biological stuff. Instead, it works on nice, pure probability distributions. You start by specifying a probability distribution for the optimal values, based on your initial guess. The CEM then
+It's basically like a [genetic algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm) without the biological analogy. Instead, it uses probability distributions. You start by specifying a probability distribution for the optimal values, based on your initial guess. The CEM then
 - generates samples based on that distribution,
 - scores them according to the objective function, and
-- uses the highest-scoring samples to update the parameters of the probability distribution, so it converges on an optimal value.
+- uses the lowest-scoring samples (that is, this library assumes that we want to minimize the objective function) to update the parameters of the probability distribution, so it converges on an optimal value.
 
-It has relatively few tunable parameters, and it automatically balances diversification and intensification. It is robust to noise in the objective function, so it is very useful for parameter tuning and simulation work.
+It has relatively few tuneable parameters, and it automatically balances diversification and intensification. It is robust to noise in the objective function, so it is very useful for parameter tuning and simulation work.
 
 ### Supported problem types
 
@@ -72,11 +73,20 @@ problem.solve
 
     gem install cross_entropy
 
+## HISTORY
+
+### 1.1.0 - 6 May 2017
+
+- Linted with rubocop
+- Improved test coverage
+- Added recent rubies in CI
+- Improved README
+
 ## LICENSE
 
 (The MIT License)
 
-Copyright (c) 2015 John Lees-Miller
+Copyright (c) 2017 John Lees-Miller
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -96,4 +106,3 @@ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

data/lib/cross_entropy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cross_entropy/version'
 
 require 'narray'
@@ -7,4 +9,3 @@ require 'cross_entropy/abstract_problem'
 require 'cross_entropy/matrix_problem'
 require 'cross_entropy/continuous_problem'
 require 'cross_entropy/beta_problem'
-

data/lib/cross_entropy/abstract_problem.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CrossEntropy
   #
   # Base class for specific problem types.
@@ -6,7 +8,7 @@ module CrossEntropy
     #
     # @param [Array] params
     #
-    def initialize params
+    def initialize(params)
       @params = params
 
       @max_iters = nil
@@ -14,14 +16,14 @@ module CrossEntropy
       @overall_min_score = 1.0 / 0.0
       @overall_min_score_sample = nil
 
-      @generate_samples = proc { raise "no generating function provided" }
-      @score_sample     = proc {|sample| raise "no score function provided" }
-      @estimate         = proc {|elite| raise "no estimate function provided" }
-      @update           = proc {|estimated_params| estimated_params }
-      @stop_decision    = proc {
-        raise "no max_iters provided" unless self.max_iters
-        self.num_iters >= self.max_iters
-      }
+      @generate_samples = proc { raise 'no generating function provided' }
+      @score_sample     = proc { |_sample| raise 'no score block provided' }
+      @estimate         = proc { |_elite| raise 'no estimate block provided' }
+      @update           = proc { |estimated_params| estimated_params }
+      @stop_decision    = proc do
+        raise 'no max_iters provided' unless max_iters
+        num_iters >= max_iters
+      end
 
       yield(self) if block_given?
     end
@@ -32,15 +34,25 @@ module CrossEntropy
     attr_accessor :num_elite
     attr_accessor :max_iters
 
-    def to_generate_samples █ @generate_samples = block end
+    def to_generate_samples(&block)
+      @generate_samples = block
+    end
 
-    def to_score_sample █ @score_sample = block end
+    def to_score_sample(&block)
+      @score_sample = block
+    end
 
-    def to_estimate █ @estimate = block end
+    def to_estimate(&block)
+      @estimate = block
+    end
 
-    def to_update █ @update = block end
+    def to_update(&block)
+      @update = block
+    end
 
-    def for_stop_decision █ @stop_decision = block end
+    def for_stop_decision(&block)
+      @stop_decision = block
+    end
 
     attr_reader :num_iters
     attr_reader :min_score
@@ -58,16 +70,16 @@ module CrossEntropy
     def solve
       @num_iters = 0
 
-      begin
+      loop do
         @min_score   = nil
         @elite_score = nil
 
         samples = @generate_samples.call
 
         # Score each sample.
-        scores = NArray.float(self.num_samples)
-        for i in 0...self.num_samples
-          sample_i = samples[i,true]
+        scores = NArray.float(num_samples)
+        (0...num_samples).each do |i|
+          sample_i = samples[i, true]
           score_i  = @score_sample.call(sample_i)
 
           # Keep track of best ever if requested.
@@ -82,7 +94,7 @@ module CrossEntropy
         # Find elite quantile (gamma).
         scores_sorted = scores.sort
         @min_score   = scores_sorted[0]
-        @elite_score = scores_sorted[self.num_elite-1]
+        @elite_score = scores_sorted[num_elite - 1]
 
         # Take all samples with scores below (or equal to) gamma; note that
         # there may be more than num_elite, due to ties.
@@ -95,8 +107,8 @@ module CrossEntropy
         self.params = @update.call(estimated_params)
 
         @num_iters += 1
-      end until @stop_decision.call
+        break if @stop_decision.call
+      end
     end
   end
 end
-

data/lib/cross_entropy/beta_problem.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CrossEntropy
   #
   # Solve a continuous optimisation problem in which the variables are bounded
@@ -8,25 +10,30 @@ module CrossEntropy
   class BetaProblem < AbstractProblem
     include NMath
 
-    def initialize alpha, beta
+    def initialize(alpha, beta)
       super [alpha, beta]
 
-      @generate_samples = proc { self.generate_beta_samples }
-      @estimate         = proc {|elite| self.estimate_mom(elite) }
+      to_generate_samples { generate_beta_samples }
+      to_estimate { |elite| estimate_mom(elite) }
 
       yield(self) if block_given?
     end
 
-    def param_alpha; params[0] end
-    def param_beta; params[1] end
+    def param_alpha
+      params[0]
+    end
+
+    def param_beta
+      params[1]
+    end
 
     #
     # Generate samples.
     #
     def generate_beta_samples
-      NArray[*param_alpha.to_a.zip(param_beta.to_a).map {|alpha, beta|
+      NArray[*param_alpha.to_a.zip(param_beta.to_a).map do |alpha, beta|
         generate_beta_sample(alpha, beta)
-      }]
+      end]
     end
 
     #
@@ -42,7 +49,7 @@ module CrossEntropy
     #
     # @return [Array] the estimated parameter arrays
     #
-    def estimate_mom elite
+    def estimate_mom(elite)
       mean = elite.mean(0)
       variance = elite.stddev(0)**2
 
@@ -61,15 +68,14 @@ module CrossEntropy
 
     private
 
-    def generate_erlang_samples k
+    def generate_erlang_samples(k)
       -log(NArray.float(k, num_samples).random).sum(0)
     end
 
-    def generate_beta_sample alpha, beta
+    def generate_beta_sample(alpha, beta)
       a = generate_erlang_samples(alpha)
       b = generate_erlang_samples(beta)
       a / (a + b)
     end
   end
 end
-

data/lib/cross_entropy/continuous_problem.rb

@@ -1,22 +1,31 @@
+# frozen_string_literal: true
+
 module CrossEntropy
   #
   # Solve a continuous optimisation problem. The sampling distribution of each
   # parameter is assumed to be a 1D Gaussian with given mean and variance.
   #
   class ContinuousProblem < AbstractProblem
-    def initialize mean, stddev
+    def initialize(mean, stddev)
       super [mean, stddev]
 
-      @generate_samples = proc { self.generate_gaussian_samples }
-      @estimate         = proc {|elite| self.estimate_ml(elite) }
+      to_generate_samples { generate_gaussian_samples }
+      to_estimate { |elite| estimate_ml(elite) }
 
       yield(self) if block_given?
     end
 
-    def param_mean; params[0] end
-    def param_stddev; params[1] end
+    def param_mean
+      params[0]
+    end
+
+    def param_stddev
+      params[1]
+    end
 
-    def sample_shape; param_mean.shape end
+    def sample_shape
+      param_mean.shape
+    end
 
     #
     # Generate samples.
@@ -36,9 +45,8 @@ module CrossEntropy
     #
     # @return [Array] the estimated parameter arrays
     #
-    def estimate_ml elite
+    def estimate_ml(elite)
       [elite.mean(0), elite.stddev(0)]
     end
   end
 end
-

data/lib/cross_entropy/matrix_problem.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CrossEntropy
   #
   # Assuming that the data are probabilities in an NArray (say dim 1 or dim 2
@@ -12,24 +14,29 @@ module CrossEntropy
     def initialize(params = nil)
       super(params)
 
-      # Configurable procs.
-      @generate_samples = proc { self.generate_samples_directly }
-      @estimate         = proc {|elite|  self.estimate_ml(elite) }
-      @update           = proc {|pr_est| pr_est }
+      to_generate_samples { generate_samples_directly }
+      to_estimate { |elite| estimate_ml(elite) }
+
+      yield(self) if block_given?
+    end
+
+    def num_variables
+      @params.shape[1]
     end
 
-    def num_variables; @params.shape[1] end
-    def num_values;    @params.shape[0] end
+    def num_values
+      @params.shape[0]
+    end
 
     #
-    # Generate samples directly from the probabilities matrix {#pr}.
+    # Generate samples directly from the probabilities matrix {#params}.
     #
     # If your problem is tightly constrained, you may want to provide a custom
     # sample generation routine that avoids infeasible solutions; see
     # {#to_generate_samples}.
     #
     def generate_samples_directly
-      self.params.tile(1,1,self.num_samples).sample_pmf_dim.transpose(1,0)
+      params.tile(1, 1, num_samples).sample_pmf_dim.transpose(1, 0)
     end
 
     #
@@ -45,12 +52,12 @@ module CrossEntropy
     # @return [NArray] {#num_variables} rows; {#num_values} columns; entries are
     # non-negative floats in [0,1] and sum to 1
     #
-    def estimate_ml elite
-      pr_est = NArray.float(self.num_values, self.num_variables)
-      for i in 0...num_variables
-        elite_i = elite[true,i]
-        for j in 0...num_values
-          pr_est[j,i] = elite_i.eq(j).count_true
+    def estimate_ml(elite)
+      pr_est = NArray.float(num_values, num_variables)
+      (0...num_variables).each do |i|
+        elite_i = elite[true, i]
+        (0...num_values).each do |j|
+          pr_est[j, i] = elite_i.eq(j).count_true
         end
       end
       pr_est /= elite.shape[0]
@@ -61,19 +68,19 @@ module CrossEntropy
     # Find most likely solution so far based on given probabilities.
     #
     # @param [NArray] pr probability matrix with {#num_variables} rows and
-    # {#num_values} columns; if not specified, the current {#pr} matrix is used
+    # {#num_values} columns; if not specified, the current {#params} matrix is
+    # used
     #
     # @return [Narray] column vector with {#num_variables} integer entries in
     # [0, {#num_values})
     #
-    def most_likely_solution pr=self.params
-      pr_eq = pr.eq(pr.max(0).tile(1,pr.shape[0]).transpose(1,0))
+    def most_likely_solution(pr = params)
+      pr_eq = pr.eq(pr.max(0).tile(1, pr.shape[0]).transpose(1, 0))
       pr_ml = NArray.int(pr_eq.shape[1])
-      for i in 0...pr_eq.shape[1]
-        pr_ml[i] = pr_eq[true,i].where[0]
+      (0...pr_eq.shape[1]).each do |i|
+        pr_ml[i] = pr_eq[true, i].where[0]
       end
       pr_ml
     end
   end
 end
-

data/lib/cross_entropy/narray_extensions.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module CrossEntropy
   #
   # Some extensions to NArray.
   #
   # Note that I've opened a pull request for general cumsum and tile, but it's
-  # still open without comment after three years, so maybe they don't like them.
+  # still open without comment after three years, and I think they have stopped
+  # working on this version of narray.
   # https://github.com/masa16/narray/pull/7
   #
   module NArrayExtensions
@@ -15,21 +18,21 @@ module CrossEntropy
       #
       # @return [NArray] self
       #
-      def cumsum_general! dim=0
+      def cumsum_general!(dim = 0)
         if self.dim > dim
           if self.dim == 1
             # use the built-in version for dimension 1
-            self.cumsum_1!
+            cumsum_1!
           else
-            # for example, if this is a matrix and dim = 0, mask_0 selects the
-            # first column of the matrix and mask_1 selects the second column;
+            # for example, if this is a matrix and dim = 0, mask0 selects the
+            # first column of the matrix and mask1 selects the second column;
             # then we just shuffle them along and accumulate.
-            mask_0 = (0...self.dim).map{|d| d == dim ? 0 : true}
-            mask_1 = (0...self.dim).map{|d| d == dim ? 1 : true}
-            while mask_1[dim] < self.shape[dim]
-              self[*mask_1] += self[*mask_0]
-              mask_0[dim] += 1
-              mask_1[dim] += 1
+            mask0 = (0...self.dim).map { |d| d == dim ? 0 : true }
+            mask1 = (0...self.dim).map { |d| d == dim ? 1 : true }
+            while mask1[dim] < shape[dim]
+              self[*mask1] += self[*mask0]
+              mask0[dim] += 1
+              mask1[dim] += 1
             end
           end
         end
@@ -43,15 +46,15 @@ module CrossEntropy
       #
       # @return [NArray]
       #
-      def cumsum_general dim=0
-        self.dup.cumsum_general!(dim)
+      def cumsum_general(dim = 0)
+        dup.cumsum_general!(dim)
       end
 
       # The built-in cumsum only does vectors (dim 1).
-      alias cumsum_1 cumsum
-      alias cumsum cumsum_general
-      alias cumsum_1! cumsum!
-      alias cumsum! cumsum_general!
+      alias_method :cumsum_1, :cumsum
+      alias_method :cumsum, :cumsum_general
+      alias_method :cumsum_1!, :cumsum!
+      alias_method :cumsum!, :cumsum_general!
 
       #
       # Replicate this array to make a tiled array; this is the matlab function
@@ -63,31 +66,34 @@ module CrossEntropy
       #
       # @return [NArray] with same typecode as self
       #
-      def tile *reps
-        if self.dim == 0 || reps.member?(0)
+      def tile(*reps)
+        if dim == 0 || reps.member?(0)
           # Degenerate case: 0 dimensions or dimension 0
-          res = NArray.new(self.typecode, 0)
+          res = NArray.new(typecode, 0)
         else
-          if reps.size <= self.dim
+          if reps.size <= dim
             # Repeat any extra dims once.
-            reps = reps + [1]*(self.dim - reps.size)
+            reps += [1] * (dim - reps.size)
             tile = self
           else
             # Have to add some more dimensions (with implicit shape[dim] = 1).
-            tile_shape = self.shape + [1]*(reps.size - self.dim)
-            tile = self.reshape(*tile_shape)
+            tile_shape = shape + [1] * (reps.size - dim)
+            tile = reshape(*tile_shape)
           end
 
           # Allocate tiled matrix.
-          res_shape = (0...tile.dim).map{|i| tile.shape[i] * reps[i]}
-          res = NArray.new(self.typecode, *res_shape)
+          res_shape = (0...tile.dim).map { |i| tile.shape[i] * reps[i] }
+          res = NArray.new(typecode, *res_shape)
 
           # Copy tiles.
           # This probably isn't the most efficient way of doing this; just doing
           # res[] = tile doesn't seem to work in general
           nested_for_zero_to(reps) do |tile_pos|
-            tile_slice = (0...tile.dim).map{|i|
-              (tile.shape[i] * tile_pos[i])...(tile.shape[i] * (tile_pos[i]+1))}
+            tile_slice = (0...tile.dim).map do |i|
+              start_index = tile.shape[i] * tile_pos[i]
+              end_index = tile.shape[i] * (tile_pos[i] + 1)
+              start_index...end_index
+            end
             res[*tile_slice] = tile
           end
         end
@@ -106,11 +112,17 @@ module CrossEntropy
       # @return [Array<Integer>] subscript corresponding to the given linear
       #         index; this is the same size as +shape+
       #
-      def index_to_subscript index
-        raise IndexError.new("out of bounds: index=#{index} for shape=#{
-          self.shape.inspect}") if index >= self.size
+      def index_to_subscript(index)
+        if index >= size
+          raise \
+            IndexError,
+            "out of bounds: index=#{index} for shape=#{shape.inspect}"
+        end
 
-        self.shape.map {|s| index, r = index.divmod(s); r }
+        shape.map do |s|
+          index, r = index.divmod(s)
+          r
+        end
       end
 
       #
@@ -130,8 +142,8 @@ module CrossEntropy
       # @return [Array<Integer>] subscripts of a randomly selected into the
       #         array; this is the same size as +shape+
       #
-      def sample_pmf r=nil
-        self.index_to_subscript(self.flatten.sample_pmf_dim(0, r))
+      def sample_pmf(r = nil)
+        index_to_subscript(flatten.sample_pmf_dim(0, r))
       end
 
       #
@@ -155,8 +167,8 @@ module CrossEntropy
       #
       # @return [NArray] integer subscripts
       #
-      def sample_pmf_dim dim=0, r=nil
-        self.cumsum(dim).sample_cdf_dim(dim, r)
+      def sample_pmf_dim(dim = 0, r = nil)
+        cumsum(dim).sample_cdf_dim(dim, r)
       end
 
       #
@@ -173,12 +185,12 @@ module CrossEntropy
       #
       # @return [NArray] integer subscripts
       #
-      def sample_cdf_dim dim=0, r=nil
+      def sample_cdf_dim(dim = 0, r = nil)
         raise 'self.dim must be > dim' unless self.dim > dim
 
         # generate random sample, unless one was given for testing
-        r_shape = (0...self.dim).map {|i| i == dim ? 1 : self.shape[i]}
-        r = NArray.new(self.typecode, *r_shape).random! unless r
+        r_shape = (0...self.dim).map { |i| i == dim ? 1 : shape[i] }
+        r = NArray.new(typecode, *r_shape).random! unless r
 
         # allocate space for results -- same size as the random sample
         res = NArray.int(*r_shape)
@@ -187,9 +199,10 @@ module CrossEntropy
         # threshold
         nested_for_zero_to(r_shape) do |slice|
           r_thresh    = r[*slice]
-          res[*slice] = self.shape[dim] - 1 # default to last
+          res[*slice] = shape[dim] - 1 # default to last
           self_slice = slice.dup
-          for self_slice[dim] in 0...self.shape[dim]
+          (0...shape[dim]).each do |i|
+            self_slice[dim] = i
             if r_thresh < self[*self_slice]
               res[*slice] = self_slice[dim]
               break
@@ -197,7 +210,7 @@ module CrossEntropy
           end
         end
 
-        res[*(0...self.dim).map {|i| i == dim ? 0 : true}]
+        res[*(0...self.dim).map { |i| i == dim ? 0 : true }]
       end
 
       private
@@ -216,9 +229,9 @@ module CrossEntropy
       #
       # @return [nil]
       #
-      def nested_for_zero_to suprema
+      def nested_for_zero_to(suprema)
         unless suprema.empty?
-          nums = suprema.map{|n| (0...n).to_a}
+          nums = suprema.map { |n| (0...n).to_a }
           nums.first.product(*nums.drop(1)).each do |num|
             yield num
           end

data/lib/cross_entropy/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module CrossEntropy
   VERSION_MAJOR = 1
-  VERSION_MINOR = 0
+  VERSION_MINOR = 1
   VERSION_PATCH = 0
   VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH].join('.')
 end

data/test/cross_entropy/beta_problem_test.rb

@@ -1,13 +1,14 @@
-require 'cross_entropy'
-require 'minitest/autorun'
+# frozen_string_literal: true
 
-class TestBetaProblem < MiniTest::Test
-  # tolerance for numerical comparisons
-  DELTA = 1e-3
+require_relative 'test_helper'
 
-  def assert_narray_close exp, obs
-    assert exp.shape == obs.shape && ((exp - obs).abs < DELTA).all?,
-      "#{exp.inspect} expected; got\n#{obs.inspect}"
+class TestBetaProblem < CrossEntropyTest
+  #
+  # Numerical tolerance for comparison. We would have to run for a long time to
+  # get within the default tolerance of 10^-6, so use a less strict tolerance.
+  #
+  def delta
+    1e-3
   end
 
   #
@@ -30,13 +31,13 @@ class TestBetaProblem < MiniTest::Test
     problem.num_elite   = 10
     problem.max_iters   = 10
 
-    problem.to_score_sample {|x| (a - x[0])**2 + b*(x[1] - x[0]**2)**2 }
+    problem.to_score_sample { |x| (a - x[0])**2 + b * (x[1] - x[0]**2)**2 }
 
-    problem.to_update {|new_alpha, new_beta|
-      smooth_alpha = smooth*new_alpha + (1 - smooth)*problem.param_alpha
-      smooth_beta = smooth*new_beta + (1 - smooth)*problem.param_beta
+    problem.to_update do |new_alpha, new_beta|
+      smooth_alpha = smooth * new_alpha + (1 - smooth) * problem.param_alpha
+      smooth_beta = smooth * new_beta + (1 - smooth) * problem.param_beta
       [smooth_alpha, smooth_beta]
-    }
+    end
 
     problem.solve
 

data/test/cross_entropy/continuous_problem_test.rb

@@ -1,27 +1,20 @@
-require 'cross_entropy'
-require 'minitest/autorun'
+# frozen_string_literal: true
 
-class TestContinuousProblem < MiniTest::Test
-  # tolerance for numerical comparisons
-  DELTA = 1e-6
+require_relative 'test_helper'
 
+class TestContinuousProblem < CrossEntropyTest
   include NMath
 
-  def assert_narray_close exp, obs
-    assert exp.shape == obs.shape && ((exp - obs).abs < DELTA).all?,
-      "#{exp.inspect} expected; got\n#{obs.inspect}"
-  end
-
   #
   # Example 3.1 from Kroese et al. 2006.
   #
-  # Maximise $e^{-(x-2)^2} + 0.8 e^{−(x+2)^2}$ for real $x$. The function has a
+  # Maximise $e^{-(x-2)^2} + 0.8 e^{-(x+2)^2}$ for real $x$. The function has a
   # global maximum at x = 2 and a local maximum at x = -2, which we should
   # avoid.
   #
   # (This is also the example on Wikipedia.)
   #
-  def test_Kroese_3_1
+  def test_kroese_3_1
     NArray.srand(567) # must use NArray's generator, not Ruby's
 
     mean = NArray[0.0]
@@ -33,7 +26,7 @@ class TestContinuousProblem < MiniTest::Test
     problem.max_iters   = 100
 
     # NB: maximising
-    problem.to_score_sample {|x| -(exp(-(x-2)**2) + 0.8 * exp(-(x+2)**2)) }
+    problem.to_score_sample { |x| -(exp(-(x - 2)**2) + 0.8 * exp(-(x + 2)**2)) }
 
     problem.solve
 
@@ -61,13 +54,13 @@ class TestContinuousProblem < MiniTest::Test
     problem.num_elite   = 10
     problem.max_iters   = 300
 
-    problem.to_score_sample {|x| (a - x[0])**2 + b*(x[1] - x[0]**2)**2 }
+    problem.to_score_sample { |x| (a - x[0])**2 + b * (x[1] - x[0]**2)**2 }
 
-    problem.to_update {|new_mean, new_stddev|
-      smooth_mean = smooth*new_mean + (1 - smooth)*problem.param_mean
-      smooth_stddev = smooth*new_stddev + (1 - smooth)*problem.param_stddev
+    problem.to_update do |new_mean, new_stddev|
+      smooth_mean = smooth * new_mean + (1 - smooth) * problem.param_mean
+      smooth_stddev = smooth * new_stddev + (1 - smooth) * problem.param_stddev
       [smooth_mean, smooth_stddev]
-    }
+    end
 
     problem.solve
 
@@ -75,4 +68,3 @@ class TestContinuousProblem < MiniTest::Test
     assert problem.num_iters <= problem.max_iters
   end
 end
-

data/test/cross_entropy/cross_entropy_test.rb

@@ -1,15 +1,8 @@
-require 'cross_entropy'
-require 'minitest/autorun'
+# frozen_string_literal: true
 
-class TestCrossEntropy < MiniTest::Test
-  # tolerance for numerical comparisons
-  DELTA = 1e-6
-
-  def assert_narray_close exp, obs
-    assert exp.shape == obs.shape && ((exp - obs).abs < DELTA).all?,
-      "#{exp.inspect} expected; got\n#{obs.inspect}"
-  end
+require_relative 'test_helper'
 
+class TestCrossEntropy < CrossEntropyTest
   def test_ce_estimate_ml
     mp = CrossEntropy::MatrixProblem.new
     mp.params        = NArray.float(2, 4).fill!(0.5)
@@ -17,10 +10,10 @@ class TestCrossEntropy < MiniTest::Test
     mp.num_elite     = 3
 
     # Note that the number of columns in elite can be > num_elite due to ties.
-    elite = NArray[[1,0,0,0],
-                   [0,1,0,0],
-                   [0,0,1,0],
-                   [0,0,0,1]]
+    elite = NArray[[1, 0, 0, 0],
+                   [0, 1, 0, 0],
+                   [0, 0, 1, 0],
+                   [0, 0, 0, 1]]
     pr_est = mp.estimate_ml(elite)
     assert_equal [2, 4], pr_est.shape
     assert_narray_close NArray[[0.75, 0.25],
@@ -29,10 +22,10 @@ class TestCrossEntropy < MiniTest::Test
                                [0.75, 0.25]], pr_est
 
     # All samples the same.
-    elite = NArray[[0,0,0,0],
-                   [1,1,1,1],
-                   [0,0,0,0],
-                   [0,0,0,0]]
+    elite = NArray[[0, 0, 0, 0],
+                   [1, 1, 1, 1],
+                   [0, 0, 0, 0],
+                   [0, 0, 0, 0]]
     pr_est = mp.estimate_ml(elite)
     assert_equal [2, 4], pr_est.shape
     assert_narray_close NArray[[1.0, 0.0],
@@ -48,17 +41,17 @@ class TestCrossEntropy < MiniTest::Test
     mp.num_elite     = 3
 
     # When there is a tie, the lowest value is taken.
-    assert_equal NArray[0,0,0], mp.most_likely_solution
+    assert_equal NArray[0, 0, 0], mp.most_likely_solution
 
-    mp.params = NArray[[0.0,0.0,0.0,1.0],
-                       [1.0,0.0,0.0,0.0],
-                       [0.2,0.2,0.2,0.4]]
-    assert_equal NArray[3,0,3], mp.most_likely_solution
+    mp.params = NArray[[0.0, 0.0, 0.0, 1.0],
+                       [1.0, 0.0, 0.0, 0.0],
+                       [0.2, 0.2, 0.2, 0.4]]
+    assert_equal NArray[3, 0, 3], mp.most_likely_solution
 
-    mp.params = NArray[[0.0,0.0,1.0,0.0],
-                       [0.0,1.0,0.0,0.0],
-                       [0.1,0.3,0.4,0.2]]
-    assert_equal NArray[2,1,2], mp.most_likely_solution
+    mp.params = NArray[[0.0, 0.0, 1.0, 0.0],
+                       [0.0, 1.0, 0.0, 0.0],
+                       [0.1, 0.3, 0.4, 0.2]]
+    assert_equal NArray[2, 1, 2], mp.most_likely_solution
   end
 
   #
@@ -66,17 +59,18 @@ class TestCrossEntropy < MiniTest::Test
   # The aim is to search for the given Boolean vector y_true.
   # The MatrixProblem's default estimation rule is equivalent to equation (8).
   #
-  def test_ce_deBoer_1
+  def test_ce_deboer_1
     NArray.srand(567) # must use NArray's generator, not Ruby's
 
     n = 10
-    y_true = NArray[1,1,1,1,1,0,0,0,0,0]
+    y_true = NArray[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
 
     mp = CrossEntropy::MatrixProblem.new
     mp.params        = NArray.float(2, n).fill!(0.5)
     mp.num_samples   = 50
     mp.num_elite     = 5
     mp.max_iters     = 10
+    mp.track_overall_min = true
 
     mp.to_score_sample do |sample|
       y_true.eq(sample).count_false # to be minimized
@@ -87,6 +81,11 @@ class TestCrossEntropy < MiniTest::Test
     if y_true != mp.most_likely_solution
       warn "expected #{y_true}; found #{mp.most_likely_solution}"
     end
+
+    if y_true != mp.overall_min_score_sample
+      warn "expected overall #{y_true}; found #{mp.overall_min_score_sample}"
+    end
+
     assert mp.num_iters <= mp.max_iters
   end
 
@@ -95,20 +94,20 @@ class TestCrossEntropy < MiniTest::Test
   # This is a max-cut problem.
   # We also do some smoothing.
   #
-  def test_ce_deBoer_2
+  def test_ce_deboer_2
     NArray.srand(567) # must use NArray's generator, not Ruby's
 
     # Cost matrix
     n = 5
-    c = NArray[[0,1,3,5,6],
-               [1,0,3,6,5],
-               [3,3,0,2,2],
-               [5,6,2,0,2],
-               [6,5,2,2,0]]
+    c = NArray[[0, 1, 3, 5, 6],
+               [1, 0, 3, 6, 5],
+               [3, 3, 0, 2, 2],
+               [5, 6, 2, 0, 2],
+               [6, 5, 2, 2, 0]]
 
     mp = CrossEntropy::MatrixProblem.new
-    mp.params         = NArray.float(2, n).fill!(0.5)
-    mp.params[true,0] = NArray[0.0,1.0] # put vertex 0 in subset 1
+    mp.params = NArray.float(2, n).fill!(0.5)
+    mp.params[true, 0] = NArray[0.0, 1.0] # put vertex 0 in subset 1
     mp.num_samples    = 50
     mp.num_elite      = 5
     mp.max_iters      = 10
@@ -116,25 +115,25 @@ class TestCrossEntropy < MiniTest::Test
 
     max_cut_score = proc do |sample|
       weight = 0
-      for i in 0...n
-        for j in 0...n
-          weight += c[j,i] if sample[i] < sample[j]
+      (0...n).each do |i|
+        (0...n).each do |j|
+          weight += c[j, i] if sample[i] < sample[j]
         end
       end
       -weight # to be minimized
     end
-    best_cut = NArray[1,1,0,0,0]
-    assert_equal(-15, max_cut_score.call(NArray[1,0,0,0,0]))
+    best_cut = NArray[1, 1, 0, 0, 0]
+    assert_equal(-15, max_cut_score.call(NArray[1, 0, 0, 0, 0]))
     assert_equal(-28, max_cut_score.call(best_cut))
 
     mp.to_score_sample(&max_cut_score)
 
     mp.to_update do |pr_iter|
-      smooth*pr_iter + (1 - smooth)*mp.params
+      smooth * pr_iter + (1 - smooth) * mp.params
     end
 
     mp.for_stop_decision do
-      #p mp.params
+      # p mp.params
       mp.num_iters >= mp.max_iters
     end
 
@@ -146,4 +145,3 @@ class TestCrossEntropy < MiniTest::Test
     assert mp.num_iters <= mp.max_iters
   end
 end
-

data/test/cross_entropy/narray_extensions_test.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class TestNArrayExtensions < CrossEntropyTest
+  using CrossEntropy::NArrayExtensions
+
+  def test_array_cumsum
+    assert_equal NArray[], NArray[].cumsum
+    assert_equal NArray[0], NArray[0].cumsum
+    assert_equal NArray[1], NArray[1].cumsum
+    assert_equal NArray[0, 1], NArray[0, 1].cumsum
+    assert_equal NArray[1, 1], NArray[1, 0].cumsum
+    assert_equal NArray[1, 2], NArray[1, 1].cumsum
+    assert_equal NArray[1, 3, 6], NArray[1, 2, 3].cumsum
+  end
+
+  def test_narray_sample_pmf
+    # Sample from vector.
+    v = NArray.float(3).fill!(1)
+    v /= v.sum
+    assert_equal 0, v.sample_pmf_dim(0, NArray[0.0])
+    assert_equal 0, v.sample_pmf_dim(0, NArray[0.333])
+    assert_equal 1, v.sample_pmf_dim(0, NArray[0.334])
+    assert_equal 1, v.sample_pmf_dim(0, NArray[0.666])
+    assert_equal 2, v.sample_pmf_dim(0, NArray[0.667])
+    assert_equal 2, v.sample_pmf_dim(0, NArray[0.999])
+
+    # Sample from vector with sum < 1.
+    v = NArray[0.5, 0.2, 0.2]
+    assert_equal 0, v.sample_pmf_dim(0, NArray[0.0])
+    assert_equal 1, v.sample_pmf_dim(0, NArray[0.5])
+    assert_equal 2, v.sample_pmf_dim(0, NArray[0.89])
+    assert_equal 2, v.sample_pmf_dim(0, NArray[0.91])
+
+    # Zero at start won't be sampled.
+    v = NArray[0.0, 0.5, 0.5]
+    assert_equal 1, v.sample_pmf_dim(0, NArray[0.0])
+    assert_equal 1, v.sample_pmf_dim(0, NArray[0.1])
+    assert_equal 2, v.sample_pmf_dim(0, NArray[0.9])
+
+    # If all entries are zero, we just choose the last one arbitrarily.
+    v = NArray[0.0, 0.0, 0.0]
+    assert_equal 2, v.sample_pmf_dim(0, NArray[0.9])
+
+    # Sample from square matrix.
+    m = NArray.float(3, 3).fill!(1)
+    m /= 3
+    assert_equal \
+      NArray[0, 0, 0], m.sample_pmf_dim(0, NArray[[0.0], [0.0], [0.0]])
+    assert_equal \
+      NArray[1, 0, 0], m.sample_pmf_dim(0, NArray[[0.4], [0.0], [0.0]])
+    assert_equal \
+      NArray[1, 2, 0], m.sample_pmf_dim(0, NArray[[0.4], [0.7], [0.0]])
+    assert_equal NArray[0, 0, 0], m.sample_pmf_dim(1, NArray[[0.0, 0.0, 0.0]])
+    assert_equal NArray[1, 0, 0], m.sample_pmf_dim(1, NArray[[0.4, 0.0, 0.0]])
+    assert_equal NArray[1, 2, 0], m.sample_pmf_dim(1, NArray[[0.4, 0.7, 0.0]])
+
+    # Sample from non-square matrix.
+    m = NArray.float(3, 2).fill!(1)
+    m /= 3
+    assert_equal NArray[0, 0], m.sample_pmf_dim(0, NArray[[0.0], [0.0]])
+    assert_equal NArray[1, 0], m.sample_pmf_dim(0, NArray[[0.4], [0.0]])
+    assert_equal NArray[1, 2], m.sample_pmf_dim(0, NArray[[0.4], [0.7]])
+
+    m = m.transpose(1, 0)
+    assert_equal NArray[0, 0], m.sample_pmf_dim(1, NArray[[0.0, 0.0]])
+    assert_equal NArray[1, 0], m.sample_pmf_dim(1, NArray[[0.4, 0.0]])
+    assert_equal NArray[1, 2], m.sample_pmf_dim(1, NArray[[0.4, 0.7]])
+
+    # Sample from a 3D array.
+    a = NArray.float(4, 3, 2).fill!(1)
+    a /= 2
+    sa = a.sample_pmf_dim(2)
+    assert_equal 2, sa.dim
+    assert_equal [0, 1], sa.to_a.flatten.uniq.sort
+  end
+
+  def test_narray_index_to_subscript
+    assert_raises(IndexError) { NArray[].index_to_subscript(0) }
+
+    assert_equal [0], NArray[0].index_to_subscript(0)
+
+    assert_equal [0], NArray[0, 0].index_to_subscript(0)
+    assert_equal [1], NArray[0, 0].index_to_subscript(1)
+
+    assert_equal [0, 0], NArray[[0, 0]].index_to_subscript(0)
+    assert_equal [1, 0], NArray[[0, 0]].index_to_subscript(1)
+    assert_raises(IndexError) { NArray[[0, 0]].index_to_subscript(2) }
+    assert_raises(IndexError) { NArray[[0, 0]].index_to_subscript(3) }
+    assert_raises(IndexError) { NArray[[0, 0]].index_to_subscript(4) }
+
+    a = NArray.int(2, 2).indgen!
+    assert_equal [0, 0], a.index_to_subscript(0)
+    assert_equal [1, 0], a.index_to_subscript(1)
+    assert_equal [0, 1], a.index_to_subscript(2)
+    assert_equal [1, 1], a.index_to_subscript(3)
+    assert_raises(IndexError) { a.index_to_subscript(4) }
+
+    a = NArray.int(2, 3).indgen!
+    (0...2).each do |j|
+      (0...3).each do |i|
+        assert_equal [j, i], a.index_to_subscript(a[j, i])
+      end
+    end
+
+    a = NArray.int(3, 2).indgen!
+    (0...3).each do |j|
+      (0...2).each do |i|
+        assert_equal [j, i], a.index_to_subscript(a[j, i])
+      end
+    end
+
+    a = NArray.int(3, 2, 4).indgen!
+    (0...3).each do |j|
+      (0...2).each do |i|
+        (0...4).each do |h|
+          assert_equal [j, i, h], a.index_to_subscript(a[j, i, h])
+        end
+      end
+    end
+  end
+
+  def test_narray_sample
+    assert_equal [0], NArray[1.0].sample_pmf
+
+    assert_equal [0], NArray[0.5, 0.5].sample_pmf(NArray[0])
+    assert_equal [0], NArray[0.5, 0.5].sample_pmf(NArray[0.49])
+    assert_equal [1], NArray[0.5, 0.5].sample_pmf(NArray[0.5])
+    assert_equal [1], NArray[0.5, 0.5].sample_pmf(NArray[1.0])
+
+    a = NArray[[0.5, 0.5]]
+    assert_equal [0, 0], a.sample_pmf(NArray[0])
+    assert_equal [0, 0], a.sample_pmf(NArray[0.49])
+    assert_equal [1, 0], a.sample_pmf(NArray[0.5])
+    assert_equal [1, 0], a.sample_pmf(NArray[1.0])
+
+    a = NArray[[0.2, 0], [0.3, 0.2]]
+    assert_equal [0, 0], a.sample_pmf(NArray[0])
+    assert_equal [0, 0], a.sample_pmf(NArray[0.19])
+    assert_equal [0, 1], a.sample_pmf(NArray[0.2]) # note [1,0] has 0 mass
+    assert_equal [1, 1], a.sample_pmf(NArray[0.5])
+    assert_equal [1, 1], a.sample_pmf(NArray[0.51])
+
+    a = NArray[[[0, 0.2], [0.2, 0.2]], [[0.1, 0.1], [0.1, 0.1]]]
+    assert_equal [1, 0, 0], a.sample_pmf(NArray[0]) # note [0,0,0] has 0 mass
+    assert_equal [1, 0, 0], a.sample_pmf(NArray[0.1])
+    assert_equal [0, 1, 0], a.sample_pmf(NArray[0.21])
+    assert_equal [1, 1, 0], a.sample_pmf(NArray[0.41])
+    assert_equal [1, 1, 0], a.sample_pmf(NArray[0.59])
+    assert_equal [0, 0, 1], a.sample_pmf(NArray[0.61])
+    assert_equal [1, 0, 1], a.sample_pmf(NArray[0.71])
+    assert_equal [0, 1, 1], a.sample_pmf(NArray[0.81])
+    assert_equal [1, 1, 1], a.sample_pmf(NArray[0.91])
+    assert_equal [1, 1, 1], a.sample_pmf(NArray[1.0])
+  end
+
+  def test_sample_pmf_examples
+    a = NArray[[0.1, 0.2, 0.7],
+               [0.3, 0.5, 0.2],
+               [0.0, 0.2, 0.8],
+               [0.7, 0.1, 0.2]]
+    assert_equal [4], a.sample_pmf_dim(0).shape
+
+    assert_equal \
+      NArray[2, 1, 2, 0],
+      a.cumsum(0).sample_cdf_dim(0, NArray[[0.5], [0.5], [0.5], [0.5]])
+
+    a = NArray.float(3, 3, 3).fill!(1).div!(3 * 3 * 3)
+    assert_equal 3, a.sample_pmf.size
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cross_entropy
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - John Lees-Miller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-02 00:00:00.000000000 Z
+date: 2017-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -30,14 +30,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.48.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.48.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
 description: Includes solvers for continuous and discrete multivariate optimisation
   problems.
 email:
@@ -58,6 +86,7 @@ files:
 - test/cross_entropy/beta_problem_test.rb
 - test/cross_entropy/continuous_problem_test.rb
 - test/cross_entropy/cross_entropy_test.rb
+- test/cross_entropy/narray_extensions_test.rb
 homepage: https://github.com/jdleesmiller/cross_entropy
 licenses: []
 metadata: {}
@@ -66,7 +95,7 @@ rdoc_options:
 - "--main"
 - README.md
 - "--title"
-- cross_entropy-1.0.0 Documentation
+- cross_entropy-1.1.0 Documentation
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -81,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Solve optimisation problems with the Cross Entropy Method.
@@ -89,4 +118,4 @@ test_files:
 - test/cross_entropy/beta_problem_test.rb
 - test/cross_entropy/continuous_problem_test.rb
 - test/cross_entropy/cross_entropy_test.rb
-has_rdoc: 
+- test/cross_entropy/narray_extensions_test.rb