Class: Algebra::Map

Inherits:
Set show all
Includes:
Powers
Defined in:
lib/algebra/finite-map.rb

Instance Attribute Summary collapse

Attributes inherited from Set

#body

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Powers

#**

Methods inherited from Set

#<, #>, #bijections, #cast, #concat, #decreasing_series, #difference, #each_member, #each_non_trivial_subset, #each_pair, #each_product, #each_subset, #empty?, #eql?, #equiv_class, #identity_map, #include?, #increasing_series, #injections, #injections0, #intersection, new_h, #pick, #power, #power_set, #product, #rehash, #separate, #shift, #singleton, #singleton?, #size, #sort, #subset?, #superset?, #surjections, #to_a, #to_ary, #union

Methods included from OperatorDomain

#left_act, #left_orbit!, #left_quotient, #left_representatives, #right_act, #right_orbit!, #right_quotient, #right_representatives

Methods included from Enumerable

#all?, #any?, #collecti, #sum

Constructor Details

#initialize(h = {}) ⇒ Map

Returns a new instance of Map.



25
26
27
 
# File 'lib/algebra/finite-map.rb', line 25

def initialize(h = {})
  @body = h
end

Instance Attribute Details

#target ⇒ Object Also known as: codomain

module Map_common



140
141
142
 
# File 'lib/algebra/finite-map.rb', line 140

def target
  @target
end

Class Method Details

.[](a = {}) ⇒ Object 



14
15
16
17
18
19
 
# File 'lib/algebra/finite-map.rb', line 14

def self.[](a = {})
  new.instance_eval do
    @body = Hash[a]
    self
  end
end

.empty_set(t = nil) ⇒ Object 



29
30
31
32
33
 
# File 'lib/algebra/finite-map.rb', line 29

def self.empty_set(t = nil)
  m = new
  m.target = t if t
  m
end

.new_a(a) ⇒ Object 



21
22
23
 
# File 'lib/algebra/finite-map.rb', line 21

def self.new_a(a)
  self[Hash[*a]]
end

.null ⇒ Object 



37
38
39
40
41
 
# File 'lib/algebra/finite-map.rb', line 37

def self.empty_set(t = nil)
  m = new
  m.target = t if t
  m
end

.phi ⇒ Object 



36
37
38
39
40
 
# File 'lib/algebra/finite-map.rb', line 36

def self.empty_set(t = nil)
  m = new
  m.target = t if t
  m
end

.singleton(x, y) ⇒ Object 



40
41
42
 
# File 'lib/algebra/finite-map.rb', line 40

def self.singleton(x, y)
  new(x => y)
end

Instance Method Details

#append(x, y) ⇒ Object 



79
80
81
 
# File 'lib/algebra/finite-map.rb', line 79

def append(x, y)
  dup.append!(x, y)
end

#append!(x, y) ⇒ Object Also known as: []= 



72
73
74
75
 
# File 'lib/algebra/finite-map.rb', line 72

def append!(x, y)
  @body.store(x, y)
  self
end

#base_class ⇒ Object 



44
45
46
 
# File 'lib/algebra/finite-map.rb', line 44

def base_class
  self.class.superclass
end

#bijective? ⇒ Boolean

Returns:

  • (Boolean) 


158
159
160
 
# File 'lib/algebra/finite-map.rb', line 158

def bijective?
  surjective? && injective?
end

#call(x) ⇒ Object Also known as: act, [] 



65
66
67
 
# File 'lib/algebra/finite-map.rb', line 65

def call(x)
  @body.fetch(x)
end

#compose(other) ⇒ Object Also known as: *

LEFT ACTION!!!



130
131
132
133
134
 
# File 'lib/algebra/finite-map.rb', line 130

def compose(other) # LEFT ACTION!!!
  m = other.map_m { |x, y| [x, call(y)] }
  m.target = target
  m
end

#domain ⇒ Object Also known as: source 



98
99
100
 
# File 'lib/algebra/finite-map.rb', line 98

def domain
  base_class.new(*@body.keys)
end

#dup ⇒ Object 



59
60
61
62
63
 
# File 'lib/algebra/finite-map.rb', line 59

def dup
  m = self.class.new(@body.dup)
  m.target = target if target
  m
end

#each(&b) ⇒ Object 



48
49
50
 
# File 'lib/algebra/finite-map.rb', line 48

def each(&b)
  @body.each(&b)
end

#empty_set(s = nil) ⇒ Object Also known as: phi, null 



52
53
54
 
# File 'lib/algebra/finite-map.rb', line 52

def empty_set(s = nil)
  self.class.empty_set(s)
end

#hash ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/algebra/finite-map.rb', line 83

def hash
  s = 0
  @body.each_key do |k, v|
    s ^= k.hash ^ ~v.hash
  end
  s
end

#identity? ⇒ Boolean

Returns:

  • (Boolean) 


145
146
147
 
# File 'lib/algebra/finite-map.rb', line 145

def identity?
  all? { |x, y| x == y }
end

#image(set = nil) ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/algebra/finite-map.rb', line 102

def image(set = nil)
  if set
    set.map_s { |k| call(k) }
  else
    base_class.new(*@body.values)
  end
end

#injective? ⇒ Boolean

Returns:

  • (Boolean) 


154
155
156
 
# File 'lib/algebra/finite-map.rb', line 154

def injective?
  image.size == source.size
end

#inspect ⇒ Object 



183
184
185
 
# File 'lib/algebra/finite-map.rb', line 183

def inspect
  @body.inspect
end

#inv_coset ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/algebra/finite-map.rb', line 166

def inv_coset
  s = phi
  if target
    target.each do |y|
      s.append!(y, base_class.phi)
    end
  end
  each do |x, y|
    if s.include? y
      s.call(y) << x
    else
      s.append!(y, base_class.singleton(x))
    end
  end
  s
end

#inv_image(s) ⇒ Object 



162
163
164
 
# File 'lib/algebra/finite-map.rb', line 162

def inv_image(s)
  source.separate { |x| s.member? act(x) }
end

#inverse ⇒ Object 



126
127
128
 
# File 'lib/algebra/finite-map.rb', line 126

def inverse
  self.class.new(@body.invert)
end

#map_m ⇒ Object 



118
119
120
121
122
123
124
 
# File 'lib/algebra/finite-map.rb', line 118

def map_m
  s = phi
  each do |x, y|
    s.append!(* yield(x, y))
  end
  s
end

#map_s ⇒ Object 



110
111
112
113
114
115
116
 
# File 'lib/algebra/finite-map.rb', line 110

def map_s
  s = base_class.phi
  each do |x, y|
    s.append!(yield(x, y))
  end
  s
end

#member?(a) ⇒ Boolean Also known as: has?

Returns:

  • (Boolean) 


91
92
93
94
 
# File 'lib/algebra/finite-map.rb', line 91

def member?(a)
  return nil unless a.is_a? Array
  @body[a.first] == a.last
end

#surjective? ⇒ Boolean

Returns:

  • (Boolean) 


149
150
151
152
 
# File 'lib/algebra/finite-map.rb', line 149

def surjective?
  raise 'target is not defined.' unless @target
  image.size == target.size
end

#to_s ⇒ Object 



187
188
189
 
# File 'lib/algebra/finite-map.rb', line 187

def to_s
  @body.inspect
end