slsp-circlemethod 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca4990c304c5d53044e494f9267067e2fd73e4ec73603e61a030cb38991eea14
+  data.tar.gz: 475064d40fd2b57cf5a6834cbcddcf9730abd3847d854272c465b7f251cda6e7
+SHA512:
+  metadata.gz: d7aa99e782c91e9f3001c57dfd3fd2ce0e41c27a09263ad9c1bb1ed40c7326d0d0731463f7838e79911ac213ae9360860800e7f0377efdb8d1ecb279819f7016
+  data.tar.gz: 5356bb63266610577d0c3ecf647ee6b300a39977dbf62a93844a6026e8ff4e0deedc538c85f5a3b6e999e250e060f0c14a1e44f396157c66dcdd0c106ddc52b9

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+## [Unreleased]
+
+
+## [1.0.0] - 2022-01-14
+
+- Initial release
+
+### Added
+- Implement CircleMethod.each()
+- Implement CircleMethod.each_with_fair_break()

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Joji Wakairo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 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/README.ja.md

@@ -0,0 +1,98 @@
+# SLSP::CircleMethod
+
+[![Ruby](https://github.com/wakairo/slsp-circlemethod/actions/workflows/main.yml/badge.svg)](https://github.com/wakairo/slsp-circlemethod/actions/workflows/main.yml)
+
+SLSP:: CircleMethodは、スポーツスケジューリング問題におけるcircle methodを用いたメソッドを提供します。
+
+## インストール
+
+このgemを利用するアプリケーションのGemfileに以下の行を追加して下さい。
+
+```ruby
+gem 'slsp-circlemethod'
+```
+
+そして、以下のコマンドを実行して下さい。
+
+    $ bundle install
+
+もし以上のようにGemfileを利用しないのであれば、以下のコマンドでインストールして下さい。
+
+    $ gem install slsp-circlemethod
+
+## 利用方法
+
+### each()
+
+SLSP::CircleMethod.each()は、Circle methodを利用することで、同時に行われる試合の集まり、つまり、ラウンドを考慮した上で、nチームの対戦スケジュールを計算します。
+
+コード例:
+```ruby
+teams = %w(A B C D  E F G H)
+enum = SLSP::CircleMethod.each_with_fair_break(teams.size)
+enum.each_slice(teams.size/2).each_with_index do |x, i|
+    puts "Round #{i}: " + x.map{|p,q| "#{teams[p]} vs #{teams[q]}"}.join(", ")
+end
+```
+
+出力:
+```
+Round 0: A vs H, G vs B, C vs F, E vs D
+Round 1: B vs H, A vs C, D vs G, F vs E
+Round 2: H vs C, B vs D, E vs A, G vs F
+Round 3: D vs H, C vs E, F vs B, A vs G
+Round 4: H vs E, D vs F, G vs C, B vs A
+Round 5: F vs H, E vs G, A vs D, C vs B
+Round 6: H vs G, F vs A, B vs E, D vs C
+```
+
+
+### each_with_fair_break()
+
+SLSP::CircleMethod.each_with_fair_break()は、さらにブレイクを考慮した上で、対戦スケジュールを計算します。
+スポーツスケジューリング問題では、ブレイクは「2回連続したホーム・ゲームまたはアウェイ・ゲーム」のことを意味します。
+以下の例では、AとB、D、Fの4チームが「hh」（2回連続したホーム・ゲーム）を持ち、CとE、G、Hの4チームが「aa」（2回連続したアウェイ・ゲーム）を持ちます。
+したがって、各チームが平等にブレイクを1つずつ持ちます。
+
+コード例:
+```ruby
+teams = %w(A B C D  E F G H)
+puts "Team   : " + teams.join(" ")
+enum = SLSP::CircleMethod.each_with_fair_break(teams.size)
+enum.each_slice(teams.size/2).each_with_index do |round, i|
+    a = []
+    round.each do |home, away|
+        a[home] = "h"
+        a[away] = "a"
+    end
+    puts "Round #{i}: " + a.join(" ")
+end
+```
+
+出力:
+```
+Team   : A B C D E F G H
+Round 0: h a h a h a h a
+Round 1: h h a h a h a a
+Round 2: a h a a h a h h
+Round 3: h a h h a h a a
+Round 4: a h a h a a h h
+Round 5: h a h a h h a a
+Round 6: a h a h a h a h
+```
+
+
+## 開発
+
+このレポジトリをチェックアウトした後に、まず`bin/setup`を実行して下さい。そして次にテストを走らせるために`rake test`を実行して下さい。
+
+このgemをローカル環境にインストールするには、`bundle exec rake install`を実行して下さい。新たなバージョンをリリースするには、`version.rb`内のバージョン番号を更新してから、`bundle exec rake release`を実行して下さい。このコマンドは、新バージョンに対するgitタグを生成し、このタグとgitコミットをpushし、`.gem`ファイルを[rubygems.org](https://rubygems.org)へpushします。
+
+## 開発への参加
+
+バグレポートとプルリクエストはGitHubへお寄せ下さい。
+https://github.com/wakairo/slsp-circlemethod
+
+## ライセンス
+
+このgemは[MIT License](https://opensource.org/licenses/MIT)の下で、オープンソースのライブラリとしてご利用可能です。

data/README.md

@@ -0,0 +1,95 @@
+# SLSP::CircleMethod
+
+[![Ruby](https://github.com/wakairo/slsp-circlemethod/actions/workflows/main.yml/badge.svg)](https://github.com/wakairo/slsp-circlemethod/actions/workflows/main.yml)
+
+SLSP:: CircleMethod provides methods using the circle method for Sports League Scheduling Problems.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'slsp-circlemethod'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install slsp-circlemethod
+
+## Usage
+
+### each()
+
+By using the circle method, SLSP::CircleMethod.each() computes schedules of matches of n teams considering rounds.
+
+Example:
+```ruby
+teams = %w(A B C D  E F G H)
+enum = SLSP::CircleMethod.each_with_fair_break(teams.size)
+enum.each_slice(teams.size/2).each_with_index do |x, i|
+    puts "Round #{i}: " + x.map{|p,q| "#{teams[p]} vs #{teams[q]}"}.join(", ")
+end
+```
+
+Output:
+```
+Round 0: A vs H, G vs B, C vs F, E vs D
+Round 1: B vs H, A vs C, D vs G, F vs E
+Round 2: H vs C, B vs D, E vs A, G vs F
+Round 3: D vs H, C vs E, F vs B, A vs G
+Round 4: H vs E, D vs F, G vs C, B vs A
+Round 5: F vs H, E vs G, A vs D, C vs B
+Round 6: H vs G, F vs A, B vs E, D vs C
+```
+
+
+### each_with_fair_break()
+
+SLSP::CircleMethod.each_with_fair_break() computes the schedules also considering breaks. In Sports League Scheduling Problems, the break means "two consecutive home matches or two consecutive away matches". 
+In the following example, team A, B, D, and F have "hh" (consecutive two home matches), and team C, E, G, and H have "aa" (consecutive two away matches). So, each team has one break fairly.
+
+Example:
+```ruby
+teams = %w(A B C D  E F G H)
+puts "Team   : " + teams.join(" ")
+enum = SLSP::CircleMethod.each_with_fair_break(teams.size)
+enum.each_slice(teams.size/2).each_with_index do |round, i|
+    a = []
+    round.each do |home, away|
+        a[home] = "h"
+        a[away] = "a"
+    end
+    puts "Round #{i}: " + a.join(" ")
+end
+```
+
+Output:
+```
+Team   : A B C D E F G H
+Round 0: h a h a h a h a
+Round 1: h h a h a h a a
+Round 2: a h a a h a h h
+Round 3: h a h h a h a a
+Round 4: a h a h a a h h
+Round 5: h a h a h h a a
+Round 6: a h a h a h a h
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wakairo/slsp-circlemethod.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "slsp/circlemethod"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/slsp/circlemethod/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SLSP
+  module CircleMethod
+    VERSION = "1.0.0"
+  end
+end

data/lib/slsp/circlemethod.rb

@@ -0,0 +1,230 @@
+require_relative "circlemethod/version"
+
+# The SLSP module defines methods for Sports League Scheduling Problems
+module SLSP
+  # The Circlemethod module defines methods using the circle method for Sports League Scheduling Problems
+  module CircleMethod
+
+    module InternalUseOnly # :nodoc: all
+      def self.convert_to_non_negative_int n
+        unless n.respond_to?(:to_int)
+          raise TypeError.new("no implicit conversion of #{n.class} into Integer")
+        end
+        i = n.to_int
+        if i < 0
+          raise RangeError.new("#{n} must be a non-negative value")
+        end
+        i
+      end
+
+      def self.each_of_even(n)
+        n_1 = n-1
+        n_1.times do |i|
+          q = i + 1
+          r = q + n - 3
+          yield [i, n_1]
+          (n/2-1).times do |j|
+            yield [q%n_1, r%n_1]
+            q+=1
+            r-=1
+          end
+        end
+      end
+      def self.each_of_odd(n)
+        n.times do |i|
+          q = i + 1
+          r = q + n - 2
+          ((n+1)/2-1).times do |j|
+            yield [q%n, r%n]
+            q+=1
+            r-=1
+          end
+        end
+      end
+      
+      def self.each_with_fair_break_of_even(n)
+        n_1 = n-1
+        n_1.times do |i|
+          q = i + 1
+          r = q + n - 3
+          yield(
+            if 0==i or i.odd?
+              [i, n_1]
+            else
+              [n_1, i]
+            end
+          )
+          (n/2-1).times do |j|
+            yield(
+              if j.even?
+                [r%n_1, q%n_1]
+              else
+                [q%n_1, r%n_1]
+              end
+            )
+            q+=1
+            r-=1
+          end
+        end
+      end
+      def self.each_with_fair_break_of_odd(n)
+        n.times do |i|
+          q = i + 1
+          r = q + n - 2
+          ((n+1)/2-1).times do |j|
+            yield(
+              if j.even?
+                [r%n, q%n]
+              else
+                [q%n, r%n]
+              end
+            )
+            q+=1
+            r-=1
+          end
+        end
+      end
+    end
+
+    # call-seq:
+    #    CircleMethod.each(n){|pair| ... }  -> nil
+    #    CircleMethod.each(n) -> new_enumerator
+    #
+    # Calls the block with pairs of two different integers,
+    # whose correspond to +n+ teams, and
+    # returns +nil+.
+    #
+    # +n+ must be a non-negative integer.
+    #
+    # Example 1:
+    #    SLSP::CircleMethod.each(4){|match| p match }
+    # Output:
+    #    [0, 3]
+    #    [1, 2]
+    #    [1, 3]
+    #    [2, 0]
+    #    [2, 3]
+    #    [0, 1]
+    #
+    # Example 2:
+    #    teams = %w(A B C D)
+    #    SLSP::CircleMethod.each(teams.size){|p,q| puts "#{teams[p]} vs #{teams[q]}" }
+    # Output:
+    #    A vs D
+    #    B vs C
+    #    B vs D
+    #    C vs A
+    #    C vs D
+    #    A vs B
+    #
+    # If no block is given, returns a new Enumerator that will enumerate with the pairs.
+    # Example 3:
+    #    teams = %w(A B C D)
+    #    enum = SLSP::CircleMethod.each(teams.size) #=> #<Enumerator: SLSP::CircleMethod:each(4)>
+    #    enum.each_slice(teams.size/2).each_with_index do |x, i|
+    #        puts "Round #{i}: " + x.map{|p,q| "#{teams[p]} vs #{teams[q]}"}.join(", ")
+    #    end
+    # Output:
+    #    Round 0: A vs D, B vs C
+    #    Round 1: B vs D, C vs A
+    #    Round 2: C vs D, A vs B
+    #
+    def self.each(n, &block)
+      i = InternalUseOnly.convert_to_non_negative_int(n)
+      unless block_given?
+        return enum_for(__method__, i){ i*(i-1)/2 }
+      end
+      if i.even?
+        InternalUseOnly.each_of_even(i, &block)
+      else
+        InternalUseOnly.each_of_odd(i, &block)
+      end
+      nil
+    end
+    
+    # call-seq:
+    #    CircleMethod.each_with_fair_break(n){|pair| ... }  -> nil
+    #    CircleMethod.each_with_fair_break(n) -> new_enumerator
+    #
+    # Calls the block with pairs of two different integers,
+    # whose correspond to +n+ teams,
+    # where all teams have the same number of breaks, and
+    # returns +nil+.
+    #
+    # +n+ must be a non-negative integer.
+    #
+    # About breaks, see the following paragraph.
+    #
+    # Example 1:
+    #    SLSP::CircleMethod.each_with_fair_break(8).each_slice(8/2){|round| p round }
+    # Output:
+    #    [[0, 7], [6, 1], [2, 5], [4, 3]]
+    #    [[1, 7], [0, 2], [3, 6], [5, 4]]
+    #    [[7, 2], [1, 3], [4, 0], [6, 5]]
+    #    [[3, 7], [2, 4], [5, 1], [0, 6]]
+    #    [[7, 4], [3, 5], [6, 2], [1, 0]]
+    #    [[5, 7], [4, 6], [0, 3], [2, 1]]
+    #    [[7, 6], [5, 0], [1, 4], [3, 2]]
+    #
+    # If no block is given, returns a new Enumerator that will enumerate with the pairs.
+    #
+    # Example 2:
+    #    teams = %w(A B C D  E F G H)
+    #    enum = SLSP::CircleMethod.each_with_fair_break(teams.size)
+    #           #=> #<Enumerator: SLSP::CircleMethod:each_with_fair_break(8)>
+    #    enum.each_slice(teams.size/2).each_with_index do |x, i|
+    #        puts "Round #{i}: " + x.map{|p,q| "#{teams[p]} vs #{teams[q]}"}.join(", ")
+    #    end
+    # Output:
+    #    Round 0: A vs H, G vs B, C vs F, E vs D
+    #    Round 1: B vs H, A vs C, D vs G, F vs E
+    #    Round 2: H vs C, B vs D, E vs A, G vs F
+    #    Round 3: D vs H, C vs E, F vs B, A vs G
+    #    Round 4: H vs E, D vs F, G vs C, B vs A
+    #    Round 5: F vs H, E vs G, A vs D, C vs B
+    #    Round 6: H vs G, F vs A, B vs E, D vs C
+    #
+    # == Breaks
+    # In Sports League Scheduling Problems, a break means
+    # "two consecutive home matches or two consecutive away matches". 
+    # In the following example,
+    # team A, B, D, and F have "hh" (consecutive two home matches), and
+    # team C, E, G, and H have "aa" (consecutive two away matches).
+    # So, each team has one break fairly.
+    #
+    # Example 3:
+    #    teams = %w(A B C D  E F G H)
+    #    puts "Team   : " + teams.join(" ")
+    #    enum = SLSP::CircleMethod.each_with_fair_break(teams.size)
+    #    enum.each_slice(teams.size/2).each_with_index do |round, i|
+    #        a = []
+    #        round.each do |home, away|
+    #            a[home] = "h"
+    #            a[away] = "a"
+    #        end
+    #        puts "Round #{i}: " + a.join(" ")
+    #    end
+    # Output:
+    #    Team   : A B C D E F G H
+    #    Round 0: h a h a h a h a
+    #    Round 1: h h a h a h a a
+    #    Round 2: a h a a h a h h
+    #    Round 3: h a h h a h a a
+    #    Round 4: a h a h a a h h
+    #    Round 5: h a h a h h a a
+    #    Round 6: a h a h a h a h
+    #
+    def self.each_with_fair_break(n, &block)
+      i = InternalUseOnly.convert_to_non_negative_int(n)
+      unless block_given?
+        return enum_for(__method__, i){ i*(i-1)/2 }
+      end
+      if i.even?
+        InternalUseOnly.each_with_fair_break_of_even(i, &block)
+      else
+        InternalUseOnly.each_with_fair_break_of_odd(i, &block)
+      end
+      nil
+    end
+  end
+end

data/sig/slsp/circlemethod.rbs

@@ -0,0 +1,9 @@
+module SLSP
+  module CircleMethod
+    VERSION: String
+    def self.each: (int n) { ([::Integer, ::Integer]) -> void } -> nil
+                 | (int n) -> ::Enumerator[[::Integer, ::Integer], nil]
+    def self.each_with_fair_break: (int n) { ([::Integer, ::Integer]) -> void } -> nil
+                                 | (int n) -> ::Enumerator[[::Integer, ::Integer], nil]
+  end
+end

data/slsp-circlemethod.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "lib/slsp/circlemethod/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "slsp-circlemethod"
+  spec.version = SLSP::CircleMethod::VERSION
+  spec.authors = ["Joji Wakairo"]
+  spec.email = ["jw1@ninegw.sakura.ne.jp"]
+
+  spec.summary = "SLSP:: CircleMethod provides methods using the circle method for Sports League Scheduling Problems."
+  spec.description = "SLSP:: CircleMethod provides methods using the circle method for Sports League Scheduling Problems. By using the circle method, this gem computes schedules of matches of n teams considering rounds and breaks, which are two consecutive home matches or two consecutive away matches."
+  spec.homepage = "https://github.com/wakairo/slsp-circlemethod"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.5.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/wakairo/slsp-circlemethod"
+  spec.metadata["changelog_uri"] = "https://github.com/wakairo/slsp-circlemethod/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "test-unit", "~> 3.0"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: slsp-circlemethod
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Joji Wakairo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 'SLSP:: CircleMethod provides methods using the circle method for Sports
+  League Scheduling Problems. By using the circle method, this gem computes schedules
+  of matches of n teams considering rounds and breaks, which are two consecutive home
+  matches or two consecutive away matches.'
+email:
+- jw1@ninegw.sakura.ne.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.ja.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/slsp/circlemethod.rb
+- lib/slsp/circlemethod/version.rb
+- sig/slsp/circlemethod.rbs
+- slsp-circlemethod.gemspec
+homepage: https://github.com/wakairo/slsp-circlemethod
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/wakairo/slsp-circlemethod
+  source_code_uri: https://github.com/wakairo/slsp-circlemethod
+  changelog_uri: https://github.com/wakairo/slsp-circlemethod/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: 'SLSP:: CircleMethod provides methods using the circle method for Sports
+  League Scheduling Problems.'
+test_files: []