Class: DaruLite::CategoricalIndex

Inherits:
Index show all
Defined in:
lib/daru_lite/index/categorical_index.rb

Instance Attribute Summary

Attributes inherited from Index

#name, #relation_hash

Instance Method Summary collapse

Methods inherited from Index

#&, __new__, #_dump, _load, coerce, #conform, #delete_at, inherited, #inspect, #is_values, #key, new, #reorder, #slice, #sort, #subset_slice, #to_df, #valid?, #|

Constructor Details

#initialize(indexes) ⇒ DaruLite::CategoricalIndex

Create a categorical index object.

Examples:

DaruLite::CategoricalIndex.new [:a, 1, :a, 1, :c]
# => #<DaruLite::CategoricalIndex(5): {a, 1, a, 1, c}>

Parameters:

  • indexes (Array<object>) —

    array of indexes



9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/daru_lite/index/categorical_index.rb', line 9

def initialize(indexes)
  # Create a hash to map each category to positional indexes
  categories = indexes.each_with_index.group_by(&:first)
  @cat_hash = categories.transform_values { |group| group.map(&:last) }

  # Map each category to a unique integer for effective storage in @array
  map_cat_int = categories.keys.each_with_index.to_h

  # To link every instance to its category,
  # it stores integer for every instance representing its category
  @array = map_cat_int.values_at(*indexes)
end

Instance Method Details

#==(other) ⇒ true, false

Compares two index object. Returns true if every instance of category occur at the same position

Examples:

a = DaruLite::CategoricalIndex.new [:a, :a, :b]
b = DaruLite::CategoricalIndex.new [:b, :a, :a]
a == b
# => false

Parameters:

  • other (DaruLite::CateogricalIndex) —

    index object to be checked against

Returns:

  • (true, false) —

    true if other is similar to self



117
118
119
120
121
 
# File 'lib/daru_lite/index/categorical_index.rb', line 117

def ==(other)
  self.class == other.class &&
    size == other.size &&
    to_h == other.to_h
end

#[](*keys) ⇒ Integer, ...

Returns the position(s) of the given category/categories or position(s). Mirrors Index#[] but resolves against the categorical structure (@cat_hash / @array) instead of @relation_hash, which CategoricalIndex never populates.

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a]
idx[:b]   # => 1
idx[:z]   # => nil

Parameters:

  • keys (Array<object>) —

    categories or positions to look up

Returns:

  • (Integer, Array<Integer>, nil) —

    position(s), or nil if absent



78
79
80
81
82
 
# File 'lib/daru_lite/index/categorical_index.rb', line 78

def [](*keys)
  pos(*keys)
rescue IndexError
  nil
end

#add(*indexes) ⇒ DaruLite::CategoricalIndex

Add specified index values to the index object

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a, :b, :c]
idx.add :d
# => #<DaruLite::CategoricalIndex(6): {a, b, a, b, c, d}>

Parameters:

  • indexes (Array<object>) —

    index values to add

Returns:



203
204
205
 
# File 'lib/daru_lite/index/categorical_index.rb', line 203

def add(*indexes)
  DaruLite::CategoricalIndex.new(to_a + indexes)
end

#at(*positions) ⇒ object

Takes positional values and returns subset of the self

capturing the categories at mentioned positions

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a, :b, :c]
idx.at 0, 1
# => #<DaruLite::CategoricalIndex(2): {a, b}>

Parameters:

  • positions (Array<Integer>) —

    positional values

Returns:

  • (object) —

    index object



186
187
188
189
190
191
192
193
194
 
# File 'lib/daru_lite/index/categorical_index.rb', line 186

def at(*positions)
  positions = preprocess_positions(*positions)
  validate_positions(*positions)
  if positions.is_a? Integer
    index_from_pos(positions)
  else
    DaruLite::CategoricalIndex.new(positions.map { |p| index_from_pos(p) })
  end
end

#categories ⇒ Object

Returns array of categories

Examples:

x = DaruLite::CategoricalIndex.new [:a, 1, :a, 1, :c]
x.categories
# => [:a, 1, :c]


41
42
43
 
# File 'lib/daru_lite/index/categorical_index.rb', line 41

def categories
  @cat_hash.keys
end

#dup ⇒ DaruLite::CategoricalIndex

Duplicates the index object and return it

Returns:



24
25
26
27
 
# File 'lib/daru_lite/index/categorical_index.rb', line 24

def dup
  # Improve it by intializing index by hash
  DaruLite::CategoricalIndex.new to_a
end

#each ⇒ Enumerator

Returns enumerator enumerating all index values in the order they occur

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :a, :b]
idx.each.to_a
# => [:a, :a, :b]

Returns:

  • (Enumerator) —

    all index values



101
102
103
104
105
106
 
# File 'lib/daru_lite/index/categorical_index.rb', line 101

def each
  return enum_for(:each) unless block_given?

  @array.each { |pos| yield cat_from_int pos }
  self
end

#empty? ⇒ true, false

Returns true if index object is storing no category

Examples:

i = DaruLite::CategoricalIndex.new []
# => #<DaruLite::CategoricalIndex(0): {}>
i.empty?
# => true

Returns:

  • (true, false) —

    true if index object is empty



159
160
161
 
# File 'lib/daru_lite/index/categorical_index.rb', line 159

def empty?
  @array.empty?
end

#include?(index) ⇒ true, false

Returns true index or category is valid

Parameters:

  • index (object) —

    the index value to look for

Returns:

  • (true, false) —

    true if index is included, false otherwise



32
33
34
 
# File 'lib/daru_lite/index/categorical_index.rb', line 32

def include?(index)
  @cat_hash.include? index
end

#index_from_pos(pos) ⇒ object

Returns index value from position

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a, :b, :c]
idx.index_from_pos 1
# => :b

Parameters:

  • pos (Integer) —

    the position to look for

Returns:

  • (object) —

    category corresponding to position



91
92
93
 
# File 'lib/daru_lite/index/categorical_index.rb', line 91

def index_from_pos(pos)
  cat_from_int @array[pos]
end

#pos(*indexes) ⇒ Object

Note:

If the argument does not a valid category it treats it as position value and return it as it is.

Returns positions given categories or positions

Examples:

x = DaruLite::CategoricalIndex.new [:a, 1, :a, 1, :c]
x.pos :a, 1
# => [0, 1, 2, 3]

Parameters:

  • indexes (Array<object>) —

    categories or positions



53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/daru_lite/index/categorical_index.rb', line 53

def pos(*indexes)
  positions = indexes.map do |index|
    if include? index
      @cat_hash[index]
    elsif index.is_a?(Numeric) && index < @array.size
      index
    else
      raise IndexError, "#{index.inspect} is neither a valid category nor a valid position"
    end
  end

  positions.flatten!
  positions.size == 1 ? positions.first : positions.sort
end

#size ⇒ Integer

Returns size of the index object

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a]
idx.size
# => 3

Returns:

  • (Integer) —

    total number of instances of all categories



148
149
150
 
# File 'lib/daru_lite/index/categorical_index.rb', line 148

def size
  @array.size
end

#subset(*indexes) ⇒ DaruLite::CategoricalIndex

Return subset given categories or positions

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a, :b, :c]
idx.subset :a, :b
# => #<DaruLite::CategoricalIndex(4): {a, b, a, b}>

Parameters:

  • indexes (Array<object>) —

    categories or positions

Returns:



171
172
173
174
175
176
 
# File 'lib/daru_lite/index/categorical_index.rb', line 171

def subset(*indexes)
  positions = pos(*indexes)
  new_index = positions.map { |pos| index_from_pos pos }

  DaruLite::CategoricalIndex.new new_index.flatten
end

#to_a ⇒ Array

Returns all the index values

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a]
idx.to_a

Returns:

  • (Array) —

    all index values



128
129
130
 
# File 'lib/daru_lite/index/categorical_index.rb', line 128

def to_a
  each.to_a
end

#to_h ⇒ Hash

Returns hash table mapping category to positions at which they occur

Examples:

idx = DaruLite::CategoricalIndex.new [:a, :b, :a]
idx.to_h
# => {:a=>[0, 2], :b=>[1]}

Returns:

  • (Hash) —

    hash table mapping category to array of positions



138
139
140
 
# File 'lib/daru_lite/index/categorical_index.rb', line 138

def to_h
  @cat_hash
end