finite-map.rd

[index] [finite-set] Algebra::Map

# Algebra::Map

Map Class

The class which represents maps.

## File Name:

- finite-map.rb

## SuperClass:

- Set

## Included Module:

- Powers

## Class Methods:

`::[[x0 => y0, [x1 => y1, [x2 => y2, ...]]]]`

  Returns the map which has values y0 at x0, y1 at x1, y2 at x2...

  Exampel:

      require "finite-map"
      include Algebra
      p Map[0 => 10, 1 => 11, 2 => 12]         #=> {0 => 10, 1 => 11, 2 => 12}
      p Map[{0 => 10, 1 => 11, 2 => 12}]       #=> {0 => 10, 1 => 11, 2 => 12}
      p Map.new(0 => 10, 1 => 11, 2 => 12)     #=> {0 => 10, 1 => 11, 2 => 12}
      p Map.new({0 => 10, 1 => 11, 2 => 12})   #=> {0 => 10, 1 => 11, 2 => 12}
      p Map.new_a([0, 10, 1, 11, 2, 12])       #=> {0 => 10, 1 => 11, 2 => 12}

`::new([x0 => y0, [x1 => y1, [x2 => y2, ...]]])`

  Returns the map which has values y0 at x0, y1 at x1, y2 at x2... This is the same as ::[].

`::new_a(a)`

  Returns the map defined so that the even-th elements are in domain and the odd-th elements are their image.

`::phi([t])`

  Return the empty map (having empty set as domain). If t is given, target= is set by t.

  Exampel:

      p Map.phi #=> {}
      p Map.phi(Set[0, 1]) #=> {}
      p Map.phi(Set[0, 1]).target #=> {0, 1}

`::empty_set`

  Alias of ::phi.

`::singleton(x, y)`

  Returns the map defined over singleton `{x}` and having value y on it.

## Methods:

`target=(s)`

  Sets the codomain s. This is used for surjective? and so on.

`codomain=(s)`

  Alias of target=.

`target`

  Returns the codomain of self

`codomain`

  Alias of target.

`source`

  Returns the domain of self.

  Example:

      require "finite-map"
      include Algebra
      m = Map[0 => 10, 1 => 11, 2 => 12]
      p m.source #=> {0, 1, 2}
      p m.target #=> nil
      m.target = Set[10, 11, 12, 13]
      p m.target #=> {10, 11, 12, 13}

`domain`

  Alias of source.

`phi([t])`

  Returns the empty map. If t given, target= t is done.

`empty_set`
`null`

  Alias of phi.

`call(x)`

  Return the value of x.

`act`
`[]`

  Alias of call.

`each`

  Iterates for each `[point, image]` of the map.

  Example:

      require "finite-map"
      include Algebra
      Map[0 => 10, 1 => 11, 2 => 12].each do |x, y|
        p [x, y] #=> [1, 11], [0, 10], [2, 12]
      end

`compose(other)`

  Returns the composition map of self and other.

  Example:

      require "finite-map"
      include Algebra
      f = Map.new(0 => 10, 1 => 11, 2 => 12)
      g = Map.new(10 => 20, 11 => 21, 12 => 22)
      p g * f #=> {0 => 20, 1 => 21, 2 => 22}

`*`

  Alias of compose.

`dup`

  Duplicates self. target is also duplicated if it is set.

`append!(x, y)`

  Let the value of x be y.

  Example:

      require "finite-map"
      include Algebra
      m = Map[0 => 10, 1 => 11]
      m.append!(2, 12)
      p m #=> {0 => 10, 1 => 11, 2 => 12}

`[x] = y`

  Alias of append!.

`append(x, y)`

  dup and append!(x, y).

`include?(x)`

  Returns true if x is in the domain.

`contains?(x)`

  Alias of include?.

`has?(a)`

  Returns true if there is `[x, y]` s.t. the value of x is y and `[x, y] == a`.

  Example:

      require "finite-map"
      include Algebra
      m = Map[0 => 10, 1 => 11]
      p m.include?(1)  #=> true
      p m.has([1, 11]) #=> true

`image([s])`

  Returns the image of self. If s is indicated, returns the image of s by self.

`inv_image(s)`

  Return the inverse image of s by self.

`map_s`

  Returns the set given by evaluation of the block, iterating over each pair of `[point, image]`.

  Example:

      require "finite-map"
      include Algebra
      p Map.new(0 => 10, 1 => 11, 2 => 12).map_s{|x, y| y - 2*x}
      #=> Set[10, 9, 8]

`map_m`

  Returns the map given by evaluation of the block, iterating over each pair of `[point, image]`. The value of the block must be the two-dimensional array `[x, y]`.

  Example:

      require "finite-map"
      include Algebra
      p Map.new(0 => 10, 1 => 11, 2 => 12).map_m{|x, y| [y, x]}
      #=> {10 => 0, 11 => 1, 12 => 2}

`inverse`

  Returns the inverse map of self.

`surjective?`

  Returns true if self is surjective. target should be set before using this.

`injective?`

  Returns true if self is injective.

`bijective?`

  Returns true if self is bijective. target should be set before using this.