finite-set-ja.rd

[index-ja] [finite-map-ja] Algebra::Set / Enumerable

# Algebra::Set

集合のクラス

集合を表現するクラスです。２つの集合 s, t に関して、 s が t に含まれる事は all? を使って、

    s.all?{|x| t.has?(x)}

で表現されます。

## ファイル名:

- finite-set.rb

## スーパークラス:

- Object

## インクルードしているモジュール:

- Enumerable

## クラスメソッド:

`::[[obj0, [obj1, [obj2, ...]]]]`

  引数の列から Set オブジェクトを生成します。

  例: 全て {"a", [1, 2], 0} を生成する。

      require "finite-set"
      p Algebra::Set[0, "a", [1, 2]]
      p Algebra::Set.new(0, "a", [1, 2])
      p Algebra::Set.new_a([0, "a", [1, 2]])
      p Algebra::Set.new_h({0=>true, "a"=>true, [1, 2]=>true})

`::new([obj0, [obj1, [obj2, ...]]])`

  引数の列から Set オブジェクトを生成します。

`::new_a(a)`

  配列 a から Set オブジェクトを生成します。

`::new_h(h)`

  Hash から Set オブジェクトを生成します。

`self.empty_set`

  空集合を生成する。

`::phi`
`::null`

  ::empty_set のエイリアスです。

`::singleton(x)`

  x 一元のみで構成される集合を生成します。

## メソッド:

`empty_set`

  空集合を生成する。

`phi`
`null`

  empty_set のエイリアスです。

`empty?`

  空集合であるとき真を返します。

`phi?`
`empty_set?`
`null?`

  empty? のエイリアスです。

`singleton(x)`

  x 一元のみで構成される集合を生成します。

`singleton?`

  一元のみで構成される集合であるとき真を返します。

`size`

  集合の大きさを返します。

`each`

  集合の各要素に関して繰り返します。繰り返しの順番は不定です。

  例:

      require "finite-set"
      include Algebra
      Set[0, 1, 2].each do |x|
        p x #=> 1, 0, 2
      end

`separate`

  集合の各要素をブロックパラメータに渡し、ブロックの値を真にする もので構成される集合を返します。

  例:

      require "finite-set"
      include Algebra
      p Set[0, 1, 2, 3].separate{|x| x % 2 == 0} #=> {2, 0}

`select_s`
`find_all_s`

  separate のエイリアスです。

`map_s`

  集合の各要素をブロックパラメータに渡し、ブロックの値によって 構成される集合を返します。

  例:

      require "finite-set"
      include Algebra
      p Set[0, 1, 2, 3].map_s{|x| x % 2 + 1} #=> {2, 1}

`pick`

  集合の要素から一つ選んで値とします。どの要素が選ばれるかは 不定です。空集合に対しては nil を返します。

`shift`

  集合の要素から一つ選んで取り出し値とします。どの要素が選ばれる かは不定です。

  例:

      require "finite-set"
      include Algebra
      s = Set[0, 1, 2, 3]
      p s.shift #=> 2
      p s #=> {0, 1, 3}

`dup`

  集合の複製を返します。（内部の Hash の複製によります。）

`append!(x)`

  集合に要素 x を付け加えます。返り値は self です。

`push`
`<<`

  append! のエイリアスです。

`append(x)`

  集合に要素 x を付け加えた複製を返します。

`concat(other)`

  集合に別の集合 other の要素を付け加えます。 （+ の破壊版です。）

`rehash`

  内部の Hash オブジェクトを rehash します。

`eql?(other)`

  集合 other と等しいとき、真を返します。 `self >= other and self <= other` と同値です。

`==`

  eql? のエイリアスです。

`hash`

  自身が Hash あるいは Set の要素となるときに利用される ハッシュ値関数です。

`include?(x)`

  集合が x を要素としているとき、真を返します。

`has?`
`contains?`

  include? のエイリアスです。

`superset?(other)`

  集合が他の集合 other を包含するとき真を返します。 `other.all{|x| has?(x)}` と同値です。

`>=`
`incl?`

  `superset?` のエイリアスです。

`subset?(other)`

  集合が他の集合 other の部分集合であるとき真を返します。 `self.all{|x| other.has?(x)}` と同値です。

`<=`
`part_of?`

  subset? のエイリアスです。

`<(other)`

  self が other の真部分集合の時真を返します。

`>(other)`

  self が other を真に含む時真を返します。

`union([other])`

  self と other の合併集合を返します。 other が省略された場合、自身を集合の集合とみなし、全ての 要素の合併を返します。

  例:

      require "finite-set"
      include Algebra
      p Set[0, 2, 4].cup Set[1, 3] #=> {0, 1, 2, 3, 4}
      s = Set[*(0...15).to_a]
      s2 = s.separate{|x| x % 2 == 0}
      s3 = s.separate{|x| x % 3 == 0}
      s5 = s.separate{|x| x % 5 == 0}
      p Set[s2, s3, s5].union #=> {1, 7, 11, 13}

`|`
`+`
`cup`

  union のエイリアスです。

`intersection([other])`

  self と other の交わりの集合を返します。 other が省略された場合、自身を集合の集合とみなし、全ての 要素の共通部分を返します。

  例:

      require "finite-set"
      include Algebra
      p Set[0, 2, 4].cap(Set[4, 2, 0]) #=> {0, 2, 4}
      s = Set[*(0..30).to_a]
      s2 = s.separate{|x| x % 2 == 0}
      s3 = s.separate{|x| x % 3 == 0}
      s5 = s.separate{|x| x % 5 == 0}
      p Set[s2, s3, s5].cap #=> {0, 30}

`&`
`cap`

  intersection のエイリアスです。

`difference(other)`

  self から other に含まれる要素を取り除いたものを返します。

`-`

  difference のエイリアスです。

`each_pair`

  集合から異なる２つの要素を取り出して、ブロックパラメータに 代入して繰り返します。

  例:

      require "finite-set"
      include Algebra
      s = Set.phi
      Set[0, 1, 2].each_pair do |x, y|
        s.push [x, y]
      end
      p s == Set[[0, 1], [0, 2], [1, 2]] #=> true

`each_member(n)`

  集合から異なる n 個の要素を取り出して、ブロックパラメータに 代入して繰り返します。

  例:

      require "finite-set"
      include Algebra
      s = Set.phi
      Set[0, 1, 2].each_member(2) do |x, y|
        s.push [x, y]
      end
      p s == Set[[0, 1], [0, 2], [1, 2]] #=> true

`each_subset`

  集合の全ての部分集合をブロックパラメータに代入して繰り返します。

  例:

      require "finite-set"
      include Algebra
      s = Set.phi
      Set[0, 1, 2].each_subset do |t|
        s.append! t
      end
      p s.size = 2**3 #=> true

`each_non_trivial_subset`

  集合の空集合でない真部分集合をブロックパラメータに代入して繰り返します。

`power_set`

  集合の全ての部分集合の集合を返します。

`each_product(other)`

  self と other の全ての要素 x, y に ついて、繰り返します。

    例:
       require "finite-set"
       include Algebra
       Set[0, 1].each_prodct(Set[0, 1]) do |x, y|
         p [x, y] #=> [0,0], [0,1], [1,0], [1,1]
       end

`product(other)`

  self と other の積集合を返します。積集合の各元 は配列 `[x, y]` です。ブロックが与えられた時は、ブロック を評価した値で構成される集合を返します。

  例:

      require "finite-set"
      include Algebra
      p Set[0, 1].product(Set[0, 1]) #=> {[0,0], [0,1], [1,0], [1,1]}
      p Set[0, 1].product(Set[0, 1]){|x, y| x + 2*y} #=> {0, 1, 2, 3]

`*`

  product のエイリアスです。

`equiv_class([equiv])`

  集合を同値関係で割った商集合を返します。同値関係の与え方は次の３通りあります。

  1. ブロックの評価値を真にする同値関係

         require "finite-set"
         include Algebra
         s = Set[0, 1, 2, 3, 4, 5]
         p s.equiv_class{|a, b| (a - b) % 3 == 0} #=> {{0, 3}, {1, 4}, {2, 5}}

  2. 引数に与えられたオブジェクトに対するメソッド call(x, y) の真偽値による同値関係

         require "finite-set"
         include Algebra
         o = Object.new
         def o.call(x, y)
           (x - y) % 3 == 0
         end
         s = Set[0, 1, 2, 3, 4, 5]
         p s.equiv_class(o) #=> {{0, 3}, {1, 4}, {2, 5}}

  3. 引数に与えられた Symbol に応じたメソッドによる同値関係

         require "finite-set"
         include Algebra
         s = Set[0, 1, 2, 3, 4, 5]
         def q(x, y)
           (x - y) % 3 == 0
         end
         p s.equiv_class(:q) #=> {{0, 3}, {1, 4}, {2, 5}}

`/`

  equiv_class のエイリアスです。

`to_a`

  集合を配列にして返します。要素の並びの順は不定です。

`to_ary`

  to_a のエイリアスです。

`sort`

  to_a の値をソートして返します。

`power(other)`

  other から self への写像全ての集合を返します。 写像は Map の元として表現されます。

  例:

      require "finite-map"
      include Algebra
      a = Set[0, 1, 2, 3]
      b = Set[0, 1, 2]
      s =
      p( (a ** b).size )      #=> 4 ** 3 = 64
      p b.surjections(a).size #=> S(3, 4) = 36
      p a.injections(b).size  #=> 4P3 = 24

`**`

  power のエイリアスです。

`surjections(other)`

  other から self への全射全ての集合を返します。

`injections(other)`

  other から self への単射全ての集合を返します。

`bijections(other)`

  other から self への全単射全ての集合を返します。

# Enumerable

## ファイル名:

- finite-set.rb

## メソッド:

`any?`

  ブロックを真にする要素があるとき、真を返します。 Enumerable#find の別名です。(built-in of ruby-1.8)

`all?`

  全ての要素についてブロックが真であるとき、真を返します。

      !any?{|x| !yield(x)}

  と定義されています。(built-in of ruby-1.8)