combinatorics 0.4.3 → 0.4.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0761711a88421b7b0214a3b585b6a843401bd1e84bb189c87a0c4167d7e5f32
+  data.tar.gz: 6c42e53311328f5d0f6c27ea339c3539046fee352dfb548155d35183a19d5aef
+SHA512:
+  metadata.gz: 1d9df890fc1669969b84e48a0b3d6126111cc6e13369308f76c274e0227fcd475a9047872ef247dc83b009f4b5d234526aa9d88c0c59cff7c9129d080c93a044
+  data.tar.gz: 53eabbc7025dbaa9e79d8fe44c8d68c0182de3b575f425f6b4d0231c88920a8ee7b8c85bfd8f94743b8a618184525d0db5264d37232bd8793396b93afbfb1a0f

data/.github/workflows/ruby.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on: [ push, pull_request ]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - 2.6
+          - 2.7
+          - '3.0'
+          - 3.1
+          - jruby
+          - truffleruby
+    name: Ruby ${{ matrix.ruby }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Install dependencies
+        run: bundle install --jobs 4 --retry 3
+      - name: Run tests
+        run: bundle exec rake test

data/.gitignore

@@ -1,8 +1,7 @@
-pkg
-doc
-web
-tmp
+/Gemfile.lock
+/pkg
+/doc
+/.yardoc
 .DS_Store
-.yardoc
 *.swp
 *~

data/ChangeLog.md

@@ -1,3 +1,8 @@
+### 0.4.4 / 2022-01-16
+
+* Fixed a bug in {Combinatorics::Choose.cardinality} for when `0`
+  is given and `0` was returned instead of `1`.
+
 ### 0.4.3 / 2012-05-28
 
 * Fixed a typo in the gemspec, which incorrectly set

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rake'
+  gem 'rubygems-tasks', '~> 0.2'
+
+  gem 'rspec',          '~> 3.0'
+
+  gem 'kramdown'
+  gem 'yard',           '~> 0.9'
+  gem 'yard-spellcheck', require: false
+end

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2012 Hal Brodigan
+Copyright (c) 2010-2022 Hal Brodigan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,15 +1,17 @@
 # Combinatorics
 
+[![CI](https://github.com/postmodern/combinatorics/actions/workflows/ruby.yml/badge.svg)](https://github.com/postmodern/combinatorics/actions/workflows/ruby.yml)
+[![Code Climate](https://codeclimate.com/github/postmodern/combinatorics.svg)](https://codeclimate.com/github/postmodern/combinatorics)
+
 * [Source](https://github.com/postmodern/combinatorics)
 * [Issues](https://github.com/postmodern/combinatorics/issues)
 * [Documentation](http://rubydoc.info/gems/combinatorics)
-* [Email](mailto:postmodern.mod3 at gmail.com)
 
 ## Description
 
 A collection of modules and methods for performing
 [Combinatoric](http://en.wikipedia.org/wiki/Combinatoric) calculations.
-Methods are defined to compute power sets, cartesian products, permutations, 
+Methods are defined to compute power sets, Cartesian products, permutations, 
 combinations, and derangements.
 
 Note: this includes k-combinations and k-permutations, i.e. only generating
@@ -22,134 +24,169 @@ never complete due to exponential computational complexity.)
 
 ## Features
 
-* Adds Haskell/Python style list comprehensions via {Array#comprehension}.
+* Adds Haskell/Python style list comprehensions via [Array#comprehension].
 * Provides reusable Combinatorics Mixins:
-  * {Combinatorics::CartesianProduct}
-  * {Combinatorics::Choose}
-  * {Combinatorics::Derange}
-  * {Combinatorics::Permute}
-  * {Combinatorics::PowerSet}
-* Adds Combinatorics conveniance methods to {Array} and {Set}:
-  * `cartesian_product`
-  * `choose`
-  * `derange`
-  * `permute`
-  * `powerset`
-* Adds conveniance methods:
-  * {Range#&}
-  * {Range#upto}
-  * {Range#downto}
-  * {Math.sigma}
-  * {Math.pi}
-  * {Math.factorial}
-  * {Math.subfactorial}
+  * [Combinatorics::CartesianProduct]
+  * [Combinatorics::Choose]
+  * [Combinatorics::Derange]
+  * [Combinatorics::Permute]
+  * [Combinatorics::PowerSet]
+* Adds Combinatorics core extension methods to {Array} and {Set}:
+  * [cartesian_product]
+  * [choose]
+  * [derange]
+  * [permute]
+  * [powerset]
+* Adds additional core extension methods:
+  * [Range#&]
+  * [Range#upto]
+  * [Range#downto]
+  * [Math.sigma]
+  * [Math.pi]
+  * [Math.factorial]
+  * [Math.subfactorial]
+
+[Array#comprehension]: https://rubydoc.info/gems/combinatorics/Array#comprehension-instance_method
+[Combinatorics::CartesianProduct]: https://rubydoc.info/gems/combinatorics/Combinatorics/CartesianProduct
+[Combinatorics::Choose]: https://rubydoc.info/gems/combinatorics/Combinatorics/Choose
+[Combinatorics::Derange]: https://rubydoc.info/gems/combinatorics/Combinatorics/Derange
+[Combinatorics::Permute]: https://rubydoc.info/gems/combinatorics/Combinatorics/Permute
+[Combinatorics::PowerSet]: https://rubydoc.info/gems/combinatorics/Combinatorics/PowerSet
+[cartesian_product]: https://rubydoc.info/gems/combinatorics/Combinatorics/CartesianProduct/Mixin#cartesian_product-instance_method
+[choose]: https://rubydoc.info/gems/combinatorics/Combinatorics/Choose/Mixin#choose-instance_method
+[derange]: https://rubydoc.info/gems/combinatorics/Combinatorics/Derange/Mixin#derange-instance_method
+[permute]: https://rubydoc.info/gems/combinatorics/Combinatorics/Permute/Mixin#permute-instance_method
+[powerset]: https://rubydoc.info/gems/combinatorics/Combinatorics/PowerSet/Mixin#powerset-instance_method
+[Range#&]: https://rubydoc.info/gems/combinatorics/Range#&-instance_method
+[Range#upto]: https://rubydoc.info/gems/combinatorics/Range#upto-instance_method
+[Range#downto]: https://rubydoc.info/gems/combinatorics/Range#downto-instance_method
+[Math.sigma]: https://rubydoc.info/gems/combinatorics/Math#sigma-class_method
+[Math.pi]: https://rubydoc.info/gems/combinatorics/Math#pi-class_method
+[Math.factorial]: https://rubydoc.info/gems/combinatorics/Math#factorial-class_method
+[Math.subfactorial]: https://rubydoc.info/gems/combinatorics/Math#subfactorial-class_method
 
 ## Examples
 
 Power-set:
 
-    Set['ab', 'cd', 'ef'].powerset
-    # => [#<Set: {}>,
-          #<Set: {"ef"}>,
-          #<Set: {"cd"}>,
-          #<Set: {"cd", "ef"}>,
-          #<Set: {"ab"}>,
-          #<Set: {"ab", "ef"}>,
-          #<Set: {"ab", "cd"}>,
-          #<Set: {"ab", "cd", "ef"}>]
+```ruby
+Set['ab', 'cd', 'ef'].powerset
+# => [#<Set: {}>,
+      #<Set: {"ef"}>,
+      #<Set: {"cd"}>,
+      #<Set: {"cd", "ef"}>,
+      #<Set: {"ab"}>,
+      #<Set: {"ab", "ef"}>,
+      #<Set: {"ab", "cd"}>,
+      #<Set: {"ab", "cd", "ef"}>]
+```
 
 Cartesian products:
 
-    require 'combinatorics/cartesian_product'
-    
-    ['a', 'b', 'c'].cartesian_product([0, 1, 2]).to_a
-    # => [["a", 0], 
-          ["b", 0], 
-          ["c", 0], 
-          ["a", 1], 
-          ["b", 1], 
-          ["c", 1], 
-          ["a", 2], 
-          ["b", 2], 
-          ["c", 2]]
+```ruby
+require 'combinatorics/cartesian_product'
+
+['a', 'b', 'c'].cartesian_product([0, 1, 2]).to_a
+# => [["a", 0], 
+      ["b", 0], 
+      ["c", 0], 
+      ["a", 1], 
+      ["b", 1], 
+      ["c", 1], 
+      ["a", 2], 
+      ["b", 2], 
+      ["c", 2]]
+```
 
 k-combinations:
 
-    require 'combinatorics/choose'
-
-    ('a'..'f').to_a.choose(2).to_a
-    # => [["a", "b"], 
-          ["a", "c"], 
-          ["a", "d"], 
-          ["a", "e"], 
-          ["a", "f"], 
-          ["b", "c"], 
-          ["b", "d"], 
-          ["b", "e"], 
-          ["b", "f"], 
-          ["c", "d"], 
-          ["c", "e"], 
-          ["c", "f"], 
-          ["d", "e"], 
-          ["d", "f"], 
-          ["e", "f"]]
+```ruby
+require 'combinatorics/choose'
+
+('a'..'f').to_a.choose(2).to_a
+# => [["a", "b"], 
+      ["a", "c"], 
+      ["a", "d"], 
+      ["a", "e"], 
+      ["a", "f"], 
+      ["b", "c"], 
+      ["b", "d"], 
+      ["b", "e"], 
+      ["b", "f"], 
+      ["c", "d"], 
+      ["c", "e"], 
+      ["c", "f"], 
+      ["d", "e"], 
+      ["d", "f"], 
+      ["e", "f"]]
+```
 
 Derangements:
 
-    require 'combinatorics/derange'
-    
-    [:_, :q, :z, :x].derange.to_a
-    # => [[:q, :_, :x, :z], 
-          [:q, :z, :x, :_], 
-          [:q, :x, :_, :z], 
-          [:z, :_, :x, :q], 
-          [:z, :x, :_, :q], 
-          [:z, :x, :q, :_], 
-          [:x, :_, :q, :z], 
-          [:x, :z, :_, :q], 
-          [:x, :z, :q, :_]]
+```ruby
+require 'combinatorics/derange'
+
+[:_, :q, :z, :x].derange.to_a
+# => [[:q, :_, :x, :z], 
+      [:q, :z, :x, :_], 
+      [:q, :x, :_, :z], 
+      [:z, :_, :x, :q], 
+      [:z, :x, :_, :q], 
+      [:z, :x, :q, :_], 
+      [:x, :_, :q, :z], 
+      [:x, :z, :_, :q], 
+      [:x, :z, :q, :_]]
+```
 
 Permutation cardinality:
 
-    require 'combinatorics/permutation'
-    
-    Combinatorics::Permute.cardinality(128)
-    # => 8256
+```ruby
+require 'combinatorics/permutation'
+
+Combinatorics::Permute.cardinality(128)
+# => 8256
+```
 
 List comprehensions:
 
-    require 'combinatorics/list_comprehension'
-
-    [(0..10).step(2),('a'..'c')].comprehension.to_a
-    # => [[0, "a"],
-          [0, "b"],
-          [0, "c"],
-          [2, "a"],
-          [2, "b"],
-          [2, "c"],
-          [4, "a"],
-          [4, "b"],
-          [4, "c"],
-          [6, "a"],
-          [6, "b"],
-          [6, "c"],
-          [8, "a"],
-          [8, "b"],
-          [8, "c"],
-          [10, "a"],
-          [10, "b"],
-          [10, "c"]]
+```ruby
+require 'combinatorics/list_comprehension'
+
+[(0..10).step(2),('a'..'c')].comprehension.to_a
+# => [[0, "a"],
+      [0, "b"],
+      [0, "c"],
+      [2, "a"],
+      [2, "b"],
+      [2, "c"],
+      [4, "a"],
+      [4, "b"],
+      [4, "c"],
+      [6, "a"],
+      [6, "b"],
+      [6, "c"],
+      [8, "a"],
+      [8, "b"],
+      [8, "c"],
+      [10, "a"],
+      [10, "b"],
+      [10, "c"]]
+```
 
 Find the intersecting sub-range between two ranges:
 
-    (1..50) & (20..100)
-    # => (20..50)
+```ruby
+(1..50) & (20..100)
+# => (20..50)
+```
 
 Enumerate over every sub-range between two ranges:
 
-    (1..5).upto(2..10).to_a
-    # => [1..5, 1..6, 1..7, 1..8, 1..9, 1..10,
-          2..5, 2..6, 2..7, 2..8, 2..9, 2..10]
+```ruby
+(1..5).upto(2..10).to_a
+# => [1..5, 1..6, 1..7, 1..8, 1..9, 1..10,
+      2..5, 2..6, 2..7, 2..8, 2..9, 2..10]
+```
 
 ## Requirements
 
@@ -157,10 +194,12 @@ Enumerate over every sub-range between two ranges:
 
 ## Install
 
-    $ gem install combinatorics
+```shell
+$ gem install combinatorics
+```
 
 ## Copyright
 
-Copyright (c) 2010-2012 Hal Brodigan
+Copyright (c) 2010-2022 Hal Brodigan
 
 See {file:LICENSE.txt} for license information.

data/Rakefile

@@ -1,39 +1,15 @@
 require 'rubygems'
-require 'rake'
 
-begin
-  gem 'rubygems-tasks', '~> 0.1'
-  require 'rubygems/tasks'
+require 'rubygems/tasks'
+Gem::Tasks.new
 
-  Gem::Tasks.new
-rescue LoadError => e
-  warn e.message
-  warn "Run `gem install rubygems-tasks` to install 'rubygems/tasks'."
-end
-
-begin
-  gem 'rspec', '~> 2.4'
-  require 'rspec/core/rake_task'
-
-  RSpec::Core::RakeTask.new
-rescue LoadError => e
-  task :spec do
-    abort "Please run `gem install rspec` to install RSpec."
-  end
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
 task :test => :spec
 task :default => :spec
 
-begin
-  gem 'yard', '~> 0.7'
-  require 'yard'
-
-  YARD::Rake::YardocTask.new  
-rescue LoadError => e
-  task :yard do
-    abort "Please run `gem install yard` to install YARD."
-  end
-end
+require 'yard'
+YARD::Rake::YardocTask.new
 
 task :benchmark do
   Dir.glob('benchmarks/*.rb') { |script| ruby(script) }

data/combinatorics.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |gem|
   gem.authors     = Array(gemspec['authors'])
   gem.email       = gemspec['email']
   gem.homepage    = gemspec['homepage']
+  gem.metadata    = gemspec['metadata'] if gemspec['metadata']
 
   glob = lambda { |patterns| gem.files & Dir[*patterns] }
 

data/gemspec.yml

@@ -13,9 +13,13 @@ email:
 homepage: https://github.com/postmodern/combinatorics#readme
 has_yard: true
 
+metadata:
+  documentation_uri: https://rubydoc.info/gems/combinatorics
+  source_code_uri:   https://github.com/postmodern/combinatorics.rb
+  bug_tracker_uri:   https://github.com/postmodern/combinatorics.rb/issues
+  changelog_uri:     https://github.com/postmodern/combinatorics.rb/blob/master/ChangeLog.md
+
 required_ruby_version: ">= 1.8.7"
 
 development_dependencies:
-  rubygems-tasks: ~> 0.1
-  rspec: ~> 2.4
-  yard: ~> 0.7
+  bundler: ~> 2.0

data/lib/combinatorics/choose/cardinality.rb

@@ -38,7 +38,7 @@ module Combinatorics
       raise(RangeError,"n must be non-negative") if n < 0
 
       case r
-      when 0   then 0
+      when 0   then 1
       when nil then Math.factorial(n)
       else
         Math.factorial(n) / (Math.factorial(r) * Math.factorial(n - r))

data/lib/combinatorics/generator.rb

@@ -5,7 +5,7 @@ module Combinatorics
   # auto-detects the `Generator` class.
   Generator = if defined?(::Generator) # 1.8.7
                 ::Generator
-              elsif defined?(::Enumerator::Generator) # 1.9
+              elsif defined?(::Enumerator::Generator) # >= 1.9.1
                 ::Enumerator::Generator
               else
                 raise(NameError,"unable to find the Generator class")

data/lib/combinatorics/version.rb

@@ -1,4 +1,4 @@
 module Combinatorics
   # Combinatorics module revision number
-  VERSION = '0.4.3'
+  VERSION = '0.4.4'
 end

data/spec/cartesian_product/cardinality_spec.rb

@@ -6,55 +6,55 @@ describe CartesianProduct do
 
   describe "cardinality" do
     it "should return 1 for cardinality(1, 1)" do 
-      subject.cardinality(1, 1).should == 1
+      expect(subject.cardinality(1, 1)).to eq(1)
     end
 
     it "should return 2 for cardinality(1, 2)" do
-      subject.cardinality(1, 2).should == 2
+      expect(subject.cardinality(1, 2)).to eq(2)
     end
 
     it "should return 2 for cardinality(2, 1)" do
-      subject.cardinality(2, 1).should == 2
+      expect(subject.cardinality(2, 1)).to eq(2)
     end
 
     it "should return 4 for cardinality(2, 2)" do
-      subject.cardinality(2, 2).should == 4
+      expect(subject.cardinality(2, 2)).to eq(4)
     end
 
     it "should return 3 for cardinality(3, 1)" do
-      subject.cardinality(3, 1).should == 3
+      expect(subject.cardinality(3, 1)).to eq(3)
     end
 
     it "should return 3 for cardinality(1, 3)" do
-      subject.cardinality(1, 3).should == 3
+      expect(subject.cardinality(1, 3)).to eq(3)
     end
 
     it "should return 6 for cardinality(2, 3)" do
-      subject.cardinality(2, 3).should == 6
+      expect(subject.cardinality(2, 3)).to eq(6)
     end
 
     it "should return 6 for cardinality(3, 2)" do
-      subject.cardinality(3, 2).should == 6
+      expect(subject.cardinality(3, 2)).to eq(6)
     end
     
     it "should return 9 for cardinality(3, 3)" do
-      subject.cardinality(3, 3).should == 9
+      expect(subject.cardinality(3, 3)).to eq(9)
     end
 
     it "should raise RangeError if c1 is negative" do
-      lambda { subject.cardinality(-1, 1) }.should raise_error(RangeError)
+      expect { subject.cardinality(-1, 1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if c2 is negative" do
-      lambda { subject.cardinality(1, -1) }.should raise_error(RangeError)
+      expect { subject.cardinality(1, -1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if c1 is zero" do
-      lambda { subject.cardinality(0, 1) }.should raise_error(RangeError)
+      expect { subject.cardinality(0, 1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if c2 is zero" do
-      lambda { subject.cardinality(1, 0) }.should raise_error(RangeError)
+      expect { subject.cardinality(1, 0) }.to raise_error(RangeError)
     end
   end