Module: Daru::Category

Defined in:
lib/daru/category.rb

Overview

rubocop:disable Metrics/ModuleLength

Constant Summary collapse

UNDEFINED =
Object.new.freeze
CODING_SCHEMES =
%i[dummy deviation helmert simple].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#base_categoryObject

Returns the value of attribute base_category


5
6
7
# File 'lib/daru/category.rb', line 5

def base_category
  @base_category
end

#coding_schemeObject

Returns the value of attribute coding_scheme


6
7
8
# File 'lib/daru/category.rb', line 6

def coding_scheme
  @coding_scheme
end

#indexObject

Returns the value of attribute index


6
7
8
# File 'lib/daru/category.rb', line 6

def index
  @index
end

#nameObject

Returns the value of attribute name


6
7
8
# File 'lib/daru/category.rb', line 6

def name
  @name
end

Instance Method Details

#==(other) ⇒ Object

Two categorical vectors are equal if their index and corresponding values are same return [true, false] true if two vectors are similar

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
other = Daru::Vector.new [:a, 1, :a, 1, :c],
  type: :category,
  index: 1..5
dv == other
# => false

512
513
514
515
516
# File 'lib/daru/category.rb', line 512

def == other
  size == other.size &&
    to_a == other.to_a &&
    index == other.index
end

#[](*indexes) ⇒ Object

Note:

Since it accepts both indexes and postions. In case of collision, argument will be treated as index

Returns vector for indexes/positions specified

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c],
  type: :category,
  index: 'a'..'e'
dv[:a, 1]
# => #<Daru::Vector(2)>
#   a   a
#   b   1
dv[0, 1]
# => #<Daru::Vector(2)>
#   a   a
#   b   1

Parameters:

  • indexes (Array)

    for which values has to be retrived

Returns:

  • vector containing values specified at specified indexes/positions


198
199
200
201
202
203
204
205
206
207
208
# File 'lib/daru/category.rb', line 198

def [] *indexes
  positions = @index.pos(*indexes)
  return category_from_position(positions) if positions.is_a? Integer

  Daru::Vector.new positions.map { |pos| category_from_position pos },
    index: @index.subset(*indexes),
    name: @name,
    type: :category,
    ordered: @ordered,
    categories: categories
end

#[]=(*indexes, val) ⇒ Object

Note:

In order to add a new category you need to associate it via #add_category

Modifies values at specified indexes/positions.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.add_category :b
dv[0] = :b
dv
# => #<Daru::Vector(5)>
#   0   b
#   1   1
#   2   a
#   3   1
#   4   c

Parameters:

  • indexes (Array)

    at which to modify value

  • val (object)

    value to assign at specific indexes/positions

Returns:

  • modified vector


252
253
254
255
256
257
258
259
260
261
# File 'lib/daru/category.rb', line 252

def []= *indexes, val
  positions = @index.pos(*indexes)

  if positions.is_a? Numeric
    modify_category_at positions, val
  else
    positions.each { |pos| modify_category_at pos, val }
  end
  self
end

#add_category(*new_categories) ⇒ Object

Associates a category to the vector.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.add_category :b
dv.categories
# => [:a, :b, :c, 1]

Parameters:

  • new_categories (Array)

    new categories to be associated


131
132
133
134
# File 'lib/daru/category.rb', line 131

def add_category(*new_categories)
  new_categories -= categories
  add_extra_categories new_categories
end

#at(*positions) ⇒ Object

Returns vector for positions specified.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.at 0..-2
# => #<Daru::Vector(4)>
#   0   a
#   1   1
#   2   a
#   3   1

Parameters:

  • positions (Array)

    at which values to be retrived.

Returns:

  • vector containing values specified at specified positions


221
222
223
224
225
226
227
228
229
230
231
232
233
234
# File 'lib/daru/category.rb', line 221

def at *positions
  original_positions = positions
  positions = coerce_positions(*positions)
  validate_positions(*positions)

  return category_from_position(positions) if positions.is_a? Integer

  Daru::Vector.new positions.map { |pos| category_from_position(pos) },
    index: @index.at(*original_positions),
    name: @name,
    type: :category,
    ordered: @ordered,
    categories: categories
end

#categoriesArray Also known as: order

Returns all the categories with the inherent order

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c],
  type: :category,
  categories: [:a, :b, :c, 1]
dv.categories
# => [:a, :b, :c, 1]

Returns:

  • (Array)

    categories of the vector with the order


322
323
324
# File 'lib/daru/category.rb', line 322

def categories
  @cat_hash.keys
end

#categories=(cat_with_order) ⇒ Object

Note:

If extra categories are specified, they get added too.

Sets order of the categories.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.categories = [:a, :b, :c, 1]
dv.categories
# => [:a, :b, :c, 1]

Parameters:

  • cat_with_order (Array)

    categories specifying their order


336
337
338
339
340
# File 'lib/daru/category.rb', line 336

def categories= cat_with_order
  validate_categories(cat_with_order)
  add_extra_categories(cat_with_order - categories)
  order_with cat_with_order
end

#contrast_code(opts = {}) ⇒ Daru::DataFrame

Note:

To set the coding scheme use #coding_scheme=

Contrast code the vector acording to the coding scheme set.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.contrast_code full: false
# => #<Daru::DataFrame(5x2)>
#         daru_1 daru_c
#       0      0      0
#       1      1      0
#       2      0      0
#       3      1      0
#       4      0      1

Parameters:

  • opts (Hash) (defaults to: {})

    The options to pass for coding.

Options Hash (opts):

  • :full (TrueClass, FalseClass) — default: false

    True if you want k variables for k categories, false if you want k-1 variables for k categories.

Returns:


494
495
496
497
498
499
500
501
# File 'lib/daru/category.rb', line 494

def contrast_code opts={}
  if opts[:user_defined]
    user_defined_coding(opts[:user_defined])
  else
    # TODO: Make various coding schemes code DRY
    send("#{coding_scheme}_coding".to_sym, opts[:full] || false)
  end
end

#count(category = UNDEFINED) ⇒ Object

Returns frequency of given category

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.count :a
# => 2
dv.count
# => 5

Parameters:

  • category (object) (defaults to: UNDEFINED)

    given category whose count has to be founded

Returns:

  • count/frequency of given category

Raises:

  • (ArgumentError)

145
146
147
148
149
150
151
# File 'lib/daru/category.rb', line 145

def count category=UNDEFINED
  return @cat_hash.values.map(&:size).inject(&:+) if category == UNDEFINED # count all
  raise ArgumentError, "Invalid category #{category}" unless
    categories.include?(category)

  @cat_hash[category].size
end

#count_values(*values) ⇒ Integer

Count the number of values specified

Examples:

dv = Daru::Vector.new [1, 2, 1, 2, 3, 4, nil, nil]
dv.count_values nil
# => 2

Parameters:

  • values (Array)

    to count for

Returns:

  • (Integer)

    the number of times the values mentioned occurs


710
711
712
713
714
# File 'lib/daru/category.rb', line 710

def count_values(*values)
  values.map { |v| @cat_hash[v].size if @cat_hash.include? v }
        .compact
        .inject(0, :+)
end

#describeDaru::Vector

Gives the summary of data using following parameters

  • size: size of the data

  • categories: total number of categories

  • max_freq: Max no of times a category occurs

  • max_category: The category which occurs max no of times

  • min_freq: Min no of times a category occurs

  • min_category: The category which occurs min no of times

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.describe
# => #<Daru::Vector(6)>
#         size            5
#   categories            3
#     max_freq            2
# max_category            a
#     min_freq            1
# min_category            c

Returns:

  • (Daru::Vector)

    Vector with index as following parameters and values as values to these parameters


633
634
635
636
637
638
639
640
641
642
# File 'lib/daru/category.rb', line 633

def describe
  Daru::Vector.new(
    size: size,
    categories: categories.size,
    max_freq: @cat_hash.values.map(&:size).max,
    max_category: @cat_hash.keys.max_by { |cat| @cat_hash[cat].size },
    min_freq: @cat_hash.values.map(&:size).min,
    min_category: @cat_hash.keys.min_by { |cat| @cat_hash[cat].size }
  )
end

#dupDaru::Vector

Duplicated a vector

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.dup
# => #<Daru::Vector(5)>
#   0   a
#   1   1
#   2   a
#   3   1
#   4   c

Returns:


115
116
117
118
119
120
121
122
# File 'lib/daru/category.rb', line 115

def dup
  Daru::Vector.new to_a.dup,
    name: @name,
    index: @index.dup,
    type: :category,
    categories: categories,
    ordered: ordered?
end

#eachEnumerator

Returns an enumerator that enumerates on categorical data

Returns:

  • (Enumerator)

    an enumerator that enumerates over data stored in vector


88
89
90
91
92
# File 'lib/daru/category.rb', line 88

def each
  return enum_for(:each) unless block_given?
  @array.each { |pos| yield cat_from_int pos }
  self
end

#frequencies(type = :count) ⇒ Daru::Vector

Returns a vector storing count/frequency of each category

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.frequencies
# => #<Daru::Vector(4)>
#   a   2
#   b   0
#   c   1
#   1   2

Returns:

  • (Daru::Vector)

    Return a vector whose indexes are categories and corresponding values are its count


164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
# File 'lib/daru/category.rb', line 164

def frequencies type=:count
  counts = @cat_hash.values.map(&:size)
  values =
    case type
    when :count
      counts
    when :fraction
      counts.map { |c| c / size.to_f }
    when :percentage
      counts.map { |c| c / size.to_f * 100 }
    else
      raise ArgumentError, 'Type should be either :count, :fraction or'\
      " :percentage. #{type} not supported."
    end
  Daru::Vector.new values, index: categories, name: name
end

#include_values?(*values) ⇒ true, false

Check if any one of mentioned values occur in the vector

Examples:

dv = Daru::Vector.new [1, 2, 3, 4, nil]
dv.include_values? nil, Float::NAN
# => true

Parameters:

  • values (Array)

    to check for

Returns:

  • (true, false)

    returns true if any one of specified values occur in the vector


680
681
682
# File 'lib/daru/category.rb', line 680

def include_values?(*values)
  values.any? { |v| @cat_hash.include?(v) && !@cat_hash[v].empty? }
end

#indexes(*values) ⇒ Array

Return indexes of values specified

Examples:

dv = Daru::Vector.new [1, 2, nil, Float::NAN], index: 11..14
dv.indexes nil, Float::NAN
# => [13, 14]

Parameters:

  • values (Array)

    to find indexes for

Returns:

  • (Array)

    array of indexes of values specified


723
724
725
726
# File 'lib/daru/category.rb', line 723

def indexes(*values)
  values &= categories
  index.to_a.values_at(*values.flat_map { |v| @cat_hash[v] }.sort)
end

#initialize_category(data, opts = {}) ⇒ Object

Note:

Base category is set to the first category encountered in the vector.

Initializes a vector to store categorical data.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c],
  type: :category,
  ordered: true,
  categories: [:a, :b, :c, 1]
# => #<Daru::Vector(5)>
#   0   a
#   1   1
#   2   a
#   3   1
#   4   c

Parameters:

  • data (Array)

    the categorical data

  • opts (Hash) (defaults to: {})

    the options

Options Hash (opts):

  • :ordered (Boolean)

    true if data is ordered, false otherwise

  • :categories (Array)

    categories to associate with the vector. It add extra categories if specified and provides order of categories also.

  • :index (object)

    gives index to vector. By default its from 0 to size-1

Returns:

  • the categorical data created


28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# File 'lib/daru/category.rb', line 28

def initialize_category data, opts={}
  @type = :category
  initialize_core_attributes data

  if opts[:categories]
    validate_categories(opts[:categories])
    add_extra_categories(opts[:categories] - categories)
    order_with opts[:categories]
  end

  # Specify if the categories are ordered or not.
  # By default its unordered
  @ordered = opts[:ordered] || false

  # The coding scheme to code with. Default is dummy coding.
  @coding_scheme = :dummy

  # Base category which won't be present in the coding
  @base_category = @cat_hash.keys.first

  # Stores the name of the vector
  @name = opts[:name]

  # Index of the vector
  @index = coerce_index opts[:index]

  self
end

#maxobject

Note:

This operation will only work if vector is ordered. To set the vector ordered do `vector.ordered = true`

Returns the maximum category acording to the order specified.

Examples:

dv = Daru::Vector.new ['second', 'second', 'third', 'first'],
  categories: ['first', 'second', 'third']
dv.max
# => 'third'

Returns:

  • (object)

    the maximum category acording to the order


416
417
418
419
# File 'lib/daru/category.rb', line 416

def max
  assert_ordered :max
  categories.last
end

#minobject

Note:

This operation will only work if vector is ordered. To set the vector ordered do `vector.ordered = true`

Returns the minimum category acording to the order specified.

Examples:

dv = Daru::Vector.new ['second', 'second', 'third', 'first'],
  categories: ['first', 'second', 'third']
dv.min
# => 'first'

Returns:

  • (object)

    the minimum category acording to the order


402
403
404
405
# File 'lib/daru/category.rb', line 402

def min
  assert_ordered :min
  categories.first
end

#ordered=(bool) ⇒ Object

Make categorical data ordered or unordered.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.ordered = true
dv.ordered?
# => true

Parameters:

  • bool (Boolean)

    true if categorical data is to be to ordered, false otherwise


310
311
312
# File 'lib/daru/category.rb', line 310

def ordered= bool
  @ordered = bool
end

#ordered?Boolean

Tells whether vector is ordered or not.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.ordered?
# => false

Returns:

  • (Boolean)

    true if vector is ordered, false otherwise


299
300
301
# File 'lib/daru/category.rb', line 299

def ordered?
  @ordered
end

#plot(*args, **options, &b) ⇒ Object

this method is overwritten: see Daru::Category#plotting_library=


78
79
80
81
82
# File 'lib/daru/category.rb', line 78

def plot(*args, **options, &b)
  init_plotting_library

  plot(*args, **options, &b)
end

#plotting_library=(lib) ⇒ Object


62
63
64
65
66
67
68
69
70
71
72
73
74
75
# File 'lib/daru/category.rb', line 62

def plotting_library= lib
  case lib
  when :gruff, :nyaplot
    @plotting_library = lib
    if Daru.send("has_#{lib}?".to_sym)
      extend Module.const_get(
        "Daru::Plotting::Category::#{lib.to_s.capitalize}Library"
      )
    end
  else
    raise ArgumentError, "Plotting library #{lib} not supported. "\
      'Supported libraries are :nyaplot and :gruff'
  end
end

#positions(*values) ⇒ Object


751
752
753
754
# File 'lib/daru/category.rb', line 751

def positions(*values)
  values &= categories
  values.flat_map { |v| @cat_hash[v] }.sort
end

#reindex!(idx) ⇒ Daru::Vector

Note:

Unlike #reorder! which takes positions as input it takes index as an input to reorder the vector

Sets new index for vector. Preserves index->value correspondence.

Examples:

dv = Daru::Vector.new [3, 2, 1], index: ['c', 'b', 'a'], type: :category
dv.reindex! ['a', 'b', 'c']
# => #<Daru::Vector(3)>
#   a   1
#   b   2
#   c   3

Parameters:

Returns:

Raises:

  • (ArgumentError)

565
566
567
568
569
570
571
572
573
574
575
576
# File 'lib/daru/category.rb', line 565

def reindex! idx
  idx = Daru::Index.new idx unless idx.is_a? Daru::Index
  raise ArgumentError, 'Invalid index specified' unless
    idx.to_a.sort == index.to_a.sort

  old_categories = categories
  data = idx.map { |i| self[i] }
  initialize_core_attributes data
  self.categories = old_categories
  self.index = idx
  self
end

#reject_values(*values) ⇒ Daru::Vector

Return a vector with specified values removed

Examples:

dv = Daru::Vector.new [1, 2, nil, Float::NAN], type: :category
dv.reject_values nil, Float::NAN
# => #<Daru::Vector(2)>
#   0   1
#   1   2

Parameters:

  • values (Array)

    to reject from resultant vector

Returns:


693
694
695
696
697
698
699
700
701
# File 'lib/daru/category.rb', line 693

def reject_values(*values)
  resultant_pos = size.times.to_a - values.flat_map { |v| @cat_hash[v] }
  dv = at(*resultant_pos)
  unless dv.is_a? Daru::Vector
    pos = resultant_pos.first
    dv = at(pos..pos)
  end
  dv.remove_unused_categories
end

#remove_unused_categoriesDaru::Vector

Note:

If base category is removed, then the first occuring category in the data is taken as base category. Order of the undeleted categories remains preserved.

Removes the unused categories

Examples:

dv = Daru::Vector.new [:one, :two, :one], type: :category,
  categories: [:three, :two, :one]
dv.remove_unused_categories
dv.categories
# => [:two, :one]

Returns:

  • (Daru::Vector)

    Makes changes in the vector itself i.e. deletes the unused categories and returns itself


383
384
385
386
387
388
389
390
391
# File 'lib/daru/category.rb', line 383

def remove_unused_categories
  old_categories = categories

  initialize_core_attributes to_a
  self.categories = old_categories & categories
  self.base_category = @cat_hash.keys.first unless
    categories.include? base_category
  self
end

#rename_categories(old_to_new) ⇒ Object

Note:

The order of categories after renaming is preserved but new categories are added at the end in the order. Also the base-category is reassigned to new value if it is renamed

Rename categories.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.rename_categories :a => :b
dv
# => #<Daru::Vector(5)>
#   0   b
#   1   1
#   2   b
#   3   1
#   4   c

Parameters:

  • old_to_new (Hash)

    a hash mapping categories whose name to be changed to their new names


358
359
360
361
362
363
364
365
366
367
368
369
# File 'lib/daru/category.rb', line 358

def rename_categories old_to_new
  old_categories = categories
  data = to_a.map do |cat|
    old_to_new.include?(cat) ? old_to_new[cat] : cat
  end

  initialize_core_attributes data
  self.categories = (old_categories - old_to_new.keys) | old_to_new.values
  self.base_category = old_to_new[base_category] if
    old_to_new.include? base_category
  self
end

#reorder!(order) ⇒ Object

Note:

Unlike #reindex! which takes index as input, it takes positions as an input to reorder the vector

Reorder the vector with given positions

Examples:

dv = Daru::Vector.new [3, 2, 1], index: ['c', 'b', 'a'], type: :category
dv.reorder! [2, 1, 0]
# => #<Daru::Vector(3)>
#   a   1
#   b   2
#   c   3

Parameters:

  • order (Array)

    the order to reorder the vector with

Returns:

  • reordered vector

Raises:

  • (ArgumentError)

543
544
545
546
547
548
549
550
551
# File 'lib/daru/category.rb', line 543

def reorder! order
  raise ArgumentError, 'Invalid order specified' unless
    order.sort == size.times.to_a
  # TODO: Room for optimization
  old_data = to_a
  new_data = order.map { |i| old_data[i] }
  initialize_core_attributes new_data
  self
end

#replace_values(old_values, new_value) ⇒ Daru::Vector

Note:

It performs the replace in place.

Replaces specified values with a new value

Examples:

dv = Daru::Vector.new [1, 2, :a, :b]
dv.replace_values [:a, :b], nil
dv
# =>
# #<Daru::Vector:19903200 @name = nil @metadata = {} @size = 4 >
#     nil
#   0   1
#   1   2
#   2 nil
#   3 nil

Parameters:

  • old_values (Array)

    array of values to replace

  • new_value (object)

    new value to replace with

Returns:

  • (Daru::Vector)

    Same vector itself with values replaced with new value


745
746
747
748
749
# File 'lib/daru/category.rb', line 745

def replace_values old_values, new_value
  old_values = [old_values] unless old_values.is_a? Array
  rename_hash = old_values.map { |v| [v, new_value] }.to_h
  rename_categories rename_hash
end

#set_at(positions, val) ⇒ Object

Modifies values at specified positions.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.add_category :b
dv.set_at [0, 1], :b
# => #<Daru::Vector(5)>
#   0   b
#   1   b
#   2   a
#   3   1
#   4   c

Parameters:

  • positions (Array)

    positions at which to modify value

  • val (object)

    value to assign at specific positions

Returns:

  • modified vector


277
278
279
280
281
# File 'lib/daru/category.rb', line 277

def set_at positions, val
  validate_positions(*positions)
  positions.map { |pos| modify_category_at pos, val }
  self
end

#sizeObject

Size of categorical data.

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.size
# => 5

Returns:

  • total number of values in the vector


289
290
291
# File 'lib/daru/category.rb', line 289

def size
  @array.size
end

#sortObject


459
460
461
# File 'lib/daru/category.rb', line 459

def sort
  dup.sort!
end

#sort!Daru::Vector

Note:

This operation will only work if vector is ordered. To set the vector ordered, do `vector.ordered = true`

Sorts the vector in the order specified.

Examples:

dv = Daru::Vector.new ['second', 'second', 'third', 'first'],
  categories: ['first', 'second', 'thrid'],
  type: :categories,
  ordered: true
dv.sort!
# => #<Daru::Vector(4)>
#       3  first
#       0 second
#       1 second
#       2  third

Returns:


436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
# File 'lib/daru/category.rb', line 436

def sort! # rubocop:disable Metrics/AbcSize
  # TODO: Simply the code
  assert_ordered :sort

  # Build sorted index
  old_index = @index.to_a
  new_index = @cat_hash.values.map do |positions|
    old_index.values_at(*positions)
  end.flatten
  @index = @index.class.new new_index

  # Build sorted data
  @cat_hash = categories.inject([{}, 0]) do |acc, cat|
    hash, count = acc
    cat_count = @cat_hash[cat].size
    cat_count.times { |i| @array[count+i] = int_from_cat(cat) }
    hash[cat] = (count...(cat_count+count)).to_a
    [hash, count + cat_count]
  end.first

  self
end

#to_aArray

Returns all categorical data

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
dv.to_a
# => [:a, 1, :a, 1, :c]

Returns:

  • (Array)

    array of all categorical data which vector is storing


100
101
102
# File 'lib/daru/category.rb', line 100

def to_a
  each.to_a
end

#to_categoryDaru::Vector

Does nothing since its already of type category.

Returns:


646
647
648
# File 'lib/daru/category.rb', line 646

def to_category
  self
end

#to_intsArray

Returns integer coding for categorical data in the order starting from 0. For example if order is [:a, :b, :c], then :a, will be coded as 0, :b as 1 and :c as 2

Examples:

dv = Daru::Vector.new [:a, 1, :a, 1, :c],
  type: :category,
  categories: [:a, :b, :c, 1]
dv.to_ints
# => [0, 1, 0, 1, 2]

Returns:

  • (Array)

    integer coding of all values of vector


527
528
529
# File 'lib/daru/category.rb', line 527

def to_ints
  @array
end

#to_non_categoryDaru::Vector

Converts a category type vector to non category type vector

Returns:


652
653
654
# File 'lib/daru/category.rb', line 652

def to_non_category
  Daru::Vector.new to_a, name: name, index: index
end

#where(bool_array) ⇒ Daru::Vector

For querying the data

Examples:

dv = Daru::Vector.new ['I', 'II', 'I', 'III', 'I', 'II'],
  type: :category,
  ordered: true,
  categories: ['I', 'II', 'III']
dv.where(dv.mt('I') & dv.lt('III'))
# => #<Daru::Vector(2)>
#   1  II
#   5  II

Parameters:

  • bool_array (object)

    arel like query syntax

Returns:


610
611
612
# File 'lib/daru/category.rb', line 610

def where bool_array
  Daru::Core::Query.vector_where self, bool_array
end