class Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Array

Public Instance Methods

>>(dummy = nil) click to toggle source

return ArrayContext for each execute

Example

[*'a'..'c'].>>.ord # => [97, 98, 99]
[*'a'..'c'].>>.'ord' # => [97, 98, 99]
[*'aa'..'ac'].>>.gsub("a", "c") # => ['cc', 'cb', 'cc']
# File lib/open_classes/array/gte_gte.rb, line 37
def >>(dummy = nil)
  ArrayContext.new(self)
end
average() click to toggle source

return average

Example

[*1..6].average # => 3.5
[1.5, 2.5].average # => 2.0
[*'a'..'z'].average # => raise TypeError
# File lib/open_classes/array/average.rb, line 13
def average
  fail TypeError, 'you have to use elements that is Numeric' unless all? { |v|v.is_a? Numeric }
  sum.to_f / size
end
exchange!(one_index, other_index) click to toggle source

exchange arrays elements

Example

[*1..6].exchange!(1, 5) # => [1, 6, 3, 4, 5, 2]
[*1..6].exchange!(1, -1) # => [1, 6, 3, 4, 5, 2]
[*1..6].exchange!(1, 6) # => [*1..6]
[].exchange!(1, 2) # => []
# File lib/open_classes/array/exchange.rb, line 14
def exchange!(one_index, other_index)
  return self unless one_index.respond_to? :to_i
  return self unless other_index.respond_to? :to_i
  one_index = one_index.to_i
  other_index = other_index.to_i
  return self if one_index.abs >= size
  return self if other_index.abs >= size
  tmp_one = self[one_index]
  self[one_index] = self[other_index]
  self[other_index] = tmp_one
  self
end
initial_memo(init) click to toggle source
# File lib/open_classes/array/together_reduce.rb, line 53
def initial_memo(init)
  return init unless init.nil?
  first.first.is_a?(Numeric) ? 0 : first.first.is_a?(String) ? '' : nil
end
tat(index)
Alias for: together_at
tclear()
Alias for: together_clear
tcompact()
Alias for: together_compact
tcompact!()
Alias for: together_compact!
tconcat(other)
Alias for: together_concat
tdelete(value)
Alias for: together_delete
tdelete_at(index)
Alias for: together_delete_at
tdelete_if(&block)
Alias for: together_delete_if
tempty?()
Alias for: together_empty?
tfill(fill_value = nil, &block)
Alias for: together_fill
tfirst(index = nil)
Alias for: together_first
tinclude?(value, is_multi = false)
Alias for: together_include?
tindex(value)
Alias for: together_index
tinsert(index, *args)
Alias for: together_insert
tlast(index = nil)
Alias for: together_last
to_html_table(options = { no_header: false }) click to toggle source

Array(Array, Array…) to html table format.

Example

[['header1', 'header2', 'header3'],['line1_1', 'line1_2', 'line1_3']].to_html_table

result

<table>
  <tr>
    <th>header1</th>
    <th>header2</th>
    <th>header3</th>
  </tr>
  <tr>
    <td>line1_1</td>
    <td>line1_2</td>
    <td>line1_3</td>
  </tr>
</table>
# File lib/open_classes/array/to_html_table.rb, line 26
def to_html_table(options = { no_header: false })
  options[:no_header] = false if options[:no_header].nil?
  cnt = options[:no_header] ? 1 : 0
  ret = reduce(['<table>']) do |rets, lines|
    ret = lines.reduce([]) do |ret, column|
      tag = (cnt == 0) ? 'th' : 'td'
      ret << "    <#{tag}>#{column}</#{tag}>"
      ret
    end
    cnt += 1
    inner_tr = ret.join("\n")
    rets << "  <tr>\n#{inner_tr}\n  </tr>"
  end.join("\n") + "\n</table>\n"
end
to_table(position = :right) click to toggle source

Array(Array, Array…) to table format.

Example

[['header1', 'header2', 'header3'],['line1_1', 'line1_2', 'line1_3']].to_table

result

|header1|header2|header3|
|line1_1|line1_2|line1_3|
# File lib/open_classes/array/to_table.rb, line 16
def to_table(position = :right)
  ret = reduce([]) do |rets, lines|
    ret = lines.reduce([]) { |a, e|a << e; a }
    rets << "|#{ret.join('|')}|"
  end.join("\n") + "\n"
  ret.justify_table(position)
end
together() click to toggle source

Arrays loop together.

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together do |first, second|
  print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
end
# File lib/open_classes/array/together.rb, line 16
def together
  if_not_contain_array_rails_type_error
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    instance_eval "yield(#{eval_each_str})"
  end
end
together_at(index) click to toggle source

Arrays bulk at.

together_at has alias :tat

same elements size case

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_at 2 # => output ['three', 3]

different elements size case

alpha = %w{one two three}
numbers = %w{1 2}
[alpha, numbers].together_at 2 # => output ['three', nil]
# File lib/open_classes/array/together_at.rb, line 23
def together_at(index)
  if_not_contain_array_rails_type_error
  reduce([]) { |ats, list|ats << list.at(index) }
end
Also aliased as: tat
together_clear() click to toggle source

Arrays bulk clear.

together_clear has alias :tclear

same elements size case

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_clear # => output [[],[]]
# File lib/open_classes/array/together_clear.rb, line 18
def together_clear
  if_not_contain_array_rails_type_error
  each(&:clear)
end
Also aliased as: tclear
together_compact() click to toggle source

Arrays bulk compact.(immutable)

together_compact has alias :tcompact

same elements size case

alpha = ['a','b','c', nil,'d']
numbers = [1, 2, nil, 3]
lists = [alpha, numbers]
ret = lists.together_compact
print lists # => output [['a','b','c', nil,'d'], [1, 2, nil, 3]]
print ret # => output [['a','b','c','d'], [1, 2, 3]]
# File lib/open_classes/array/together_compact.rb, line 21
def together_compact
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.compact }
end
Also aliased as: tcompact
together_compact!() click to toggle source

Arrays bulk compact!.(mutable)

together_compact! has alias :tcompact!

same elements size case

alpha = ['a','b','c', nil,'d']
numbers = [1, 2, nil, 3]
lists = [alpha, numbers]
ret = lists.together_compact!
print lists # => output [['a','b','c','d'], [1, 2, 3]]
print ret # => output [['a','b','c','d'], [1, 2, 3]]
# File lib/open_classes/array/together_compact.rb, line 37
def together_compact!
  if_not_contain_array_rails_type_error
  each(&:compact!)
end
Also aliased as: tcompact!
together_concat(other) click to toggle source

Arrays bulk concat.

together_concat has alias :tconcat

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together do |first, second|
  print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
end
# File lib/open_classes/array/together_concat.rb, line 19
def together_concat(other)
  if_not_contain_array_rails_type_error
  each { |list|list.concat other }
end
Also aliased as: tconcat
together_delete(value) { |: nil| ... } click to toggle source

Arrays bulk delete.

together_delete has alias :tdelete

if delete target is exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete 2
print ret # => 2
print lists # => output [[1, 3, 4], [3, 4, 5]]

if delete target is not exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete 6
print ret # => nil
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]

if delete target is not exist and use block

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete(6) { 999 }
print ret # => 999
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]
# File lib/open_classes/array/together_delete.rb, line 37
def together_delete(value)
  if_not_contain_array_rails_type_error
  ret = []
  each { |list|ret << list.delete(value) }
  default_return = block_given? ? yield : nil
  ret.compact.size == 0 ? default_return : value
end
Also aliased as: tdelete
together_delete_at(index) click to toggle source

Arrays bulk delete_at.

together_delete_at has alias :tdelete_at

if delete_at target is exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at 2
print ret # => [3, 4]
print lists # => output [[1, 2, 4], [2, 3, 5]]

if delete_at target is not exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at 6
print ret # => [nil, nil]
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]

if delete_at target is exist(minus index)

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at -3
print ret # => [2, 3]
print lists # => output [[1, 3, 4], [2, 4, 5]]
# File lib/open_classes/array/together_delete_at.rb, line 37
def together_delete_at(index)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.delete_at(index) }
end
Also aliased as: tdelete_at
together_delete_if(&block) click to toggle source

Arrays bulk delete_if.

together_delete_if has alias :tdelete_if

if delete_if target is exist. return self.

lists = [[1, 2, 3, 4], [6, 4, 6, 8]]
ret = lists.together_delete_if {|first, second|(first + second).odd?}
print ret # => [[2, 4], [4, 8]]

if delete_if target is not exist. return nil.

lists = [[2, 2, 4, 4], [6, 4, 6, 8]]
ret = lists.together_delete_if {|first, second|(first + second).odd?}
print ret # => nil
# File lib/open_classes/array/together_delete_if.rb, line 23
def together_delete_if(&block)
  if_not_contain_array_rails_type_error
  have_deleted = false
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    is_delete = instance_eval "yield(#{eval_each_str})"
    if is_delete
      each { |e|e.delete_at i }
      have_deleted = true
    end
  end
  have_deleted ? self : nil
end
Also aliased as: tdelete_if
together_empty?() click to toggle source

Arrays bulk empty?.

together_empty? has alias :tempty?

empty case

lists = [[], []]
ret = lists.together_empty?
print ret # => true

not empty case

lists = [[1], []]
ret = lists.together_empty?
print ret # => false
# File lib/open_classes/array/together_empty.rb, line 23
def together_empty?
  if_not_contain_array_rails_type_error
  is_empty = true
  each { |list|is_empty &&= list.empty? }
  is_empty
end
Also aliased as: tempty?
together_fill(fill_value = nil) { |i| ... } click to toggle source

Arrays bulk fill.

together_fill has alias :tfill

not use block case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill(99)
print ret # => [[99, 99, 99, 99, 99], [99, 99, 99, 99, 99]]

use block, no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill { |i|(i + 1) + 1 }
print ret # => [[2, 3, 4, 5, 6], [2, 3, 4, 5, 6]]

use block, has args case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill(2) { |i|(i + 1) + 1 }
print ret # => [[1, 2, 4, 5, 6], [6, 7, 4, 5, 6]]
# File lib/open_classes/array/together_fill.rb, line 28
def together_fill(fill_value = nil, &block)
  if_not_contain_array_rails_type_error
  if block
    fill_value = 0 if fill_value.nil?
    first.each_with_index do |i_v, i|
      next if i < fill_value
      each { |list|list[i] = yield(i) }
    end
  else
    each { |list|list.fill fill_value }
  end
  self
end
Also aliased as: tfill
together_first(index = nil) click to toggle source

Arrays bulk first.

together_first has alias :tfirst

no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_first
print ret # => [1, 6]

has args 2 case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 2
print ret # => [[1, 2], [6, 7]]

has args 0 case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 0
print ret # => [[], []]

has args over size case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 6
print ret # => [[*1..5], [*6..10]]
# File lib/open_classes/array/together_first.rb, line 33
def together_first(index = nil)
  if_not_contain_array_rails_type_error
  each_return = index == 0 ? '[]' : index.nil? ? 'list.first' : 'list.first(index)'
  reduce([]) { |ret, list|ret << eval(each_return, binding) }
end
Also aliased as: tfirst
together_include?(value, is_multi = false) click to toggle source

Arrays bulk include?.

together_include? has alias :tinclude?

both include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5
print ret # => true

one include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9
print ret # => true

both not include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10
print ret # => false

both include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5, true
print ret # => [true, true]

one include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9, true
print ret # => [false, true]

both not include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10, true
print ret # => [false, false]
# File lib/open_classes/array/together_include.rb, line 43
def together_include?(value, is_multi = false)
  if_not_contain_array_rails_type_error
  return reduce([]) { |ret, list|ret << list.include?(value) } if is_multi
  reduce(false) { |ret, list|ret ||= list.include?(value) }
end
Also aliased as: tinclude?
together_index(value) click to toggle source

Arrays bulk index.

together_index has alias :tindex

both index exist case

lists = [[*1..5], [*5..9]]
ret = lists.together_index 5
print ret # => [4, 0]

one include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_index 4
print ret # => [3, nil]

both not include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_index 10
print ret # => [nil, nil]
# File lib/open_classes/array/together_index.rb, line 28
def together_index(value)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.index(value) }
end
Also aliased as: tindex
together_insert(index, *args) click to toggle source

Arrays bulk insert.

together_insert has alias :tinsert

both insert exist case

lists = [[*1..5], [*5..9]]
ret = lists.together_insert(1, 55, 66)
print ret # => [[1, 55, 66, 2, 3, 4, 5], [5, 55, 66, 6, 7, 8, 9]]

both insert exist and minus index case

lists = [[*1..5], [*5..9]]
ret = lists.together_insert(-2, 55, 66)
print ret # => [[1, 2, 3, 4, 55, 66, 5], [5, 6, 7, 8, 55, 66, 9]]

both insert exist case

lists = [[*1..5], [*5..9]]
ret = lists.together_insert(6, 55, 66)
print ret # => [[1, 2, 3, 4, 5, nil, 55, 66], [5, 6, 7, 8, 9, nil, 55, 66]],
# File lib/open_classes/array/together_insert.rb, line 28
def together_insert(index, *args)
  if_not_contain_array_rails_type_error
  each { |list|list.insert(index, *args) }
end
Also aliased as: tinsert
together_last(index = nil) click to toggle source

Arrays bulk last.

together_last has alias :tlast

no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_last
print ret # => [5, 10]

has args 2 case

lists = [[*1..5], [*6..10]]
ret = lists.together_last 2
print ret # => [[4, 5], [9, 10]]

has args 0 case

lists = [[*1..5], [*6..10]]
ret = lists.together_last 0
print ret # => [[], []]

has args over size case

lists = [[*1..5], [*6..10]]
ret = lists.together_last 6
print ret # => [[*1..5], [*6..10]]
# File lib/open_classes/array/together_last.rb, line 33
def together_last(index = nil)
  if_not_contain_array_rails_type_error
  each_return = index == 0 ? '[]' : index.nil? ? 'list.last' : 'list.last(index)'
  reduce([]) { |ret, list|ret << eval(each_return, binding) }
end
Also aliased as: tlast
together_map() click to toggle source

Arrays together map.

together_map has aliases [:tmap, :together_collect, :tcollect]

if you want to single Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
print [alpha, numbers].together_map do |first, second|
  "#{first}:#{second}\n"
end # => output one:1, two:2, three:3

if you want to multi Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
print [alpha, numbers].together_map do |first, second|
  ["#{first}:#{second}", "#{second}:#{first}"]
end # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
# File lib/open_classes/array/together_map.rb, line 27
def together_map
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_map(ret, each_ret, i)
  end
  ret
end
together_map!() click to toggle source

Arrays together map!.

together_map! has aliases [:tmap!, :together_collect!, :tcollect!]

if you want to single Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
ary = [alpha, numbers]
ret = ary.together_map! do |first, second|
  "#{first}:#{second}"
end
print ret # => output ['one:1', 'two:2', 'three:3']
print ary # => output ['one:1', 'two:2', 'three:3']

if you want to multi Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
ary = [alpha, numbers]
ret = ary.together_map! do |first, second|
  ["#{first}:#{second}", "#{second}:#{first}"]
end
print ret # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
print ary # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
# File lib/open_classes/array/together_map.rb, line 61
def together_map!
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_map(ret, each_ret, i)
  end
  clear
  ret.each { |v|self << v }
end
together_pop(count = nil) click to toggle source

Arrays bulk pop.

together_pop has alias :tpop

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_pop
print ret # => [2, 6]
print lists # => [1, 5]

empty case

lists = [[], []]
ret = lists.together_pop
print ret # => [nil, nil]
print lists # => [[], []]

not empty case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_pop 2
print ret # => [[1, 2], [5, 6]]
print lists # => [[], []]

not empty case with args

lists = [[], []]
ret = lists.together_pop 2
print ret # => [[], []]
print lists # => [[], []]
# File lib/open_classes/array/together_pop.rb, line 37
def together_pop(count = nil)
  if_not_contain_array_rails_type_error
  if count.nil?
    reduce([]) { |ret, list|ret << list.pop }
  else
    reduce([]) { |ret, list|ret << list.pop(count) }
  end
end
Also aliased as: tpop
together_reduce(init = nil) click to toggle source

Arrays loop together reduce.

together_reduce has aliases [:treduce, :together_inject, :tinject]

if you want to single return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce{|memo, first, second|memo + first + second}
print ret # => output  20

if you want to single return with init value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce(10){|memo, first, second|memo + first + second}
print ret # => output  30

if you want to single return with init string value

firsts = %w{a b c}
seconds =  %w{1 2 3}
ret = [firsts, seconds].together_reduce('start-'){|memo, first, second|memo + first + second}
print ret # => output 'start-a1b2c3'

if you want to single return with init Array value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce([]){|memo, first, second|memo << first + second}
print ret # => output [5, 4, 6, 5]

if you want to single return with init Hash value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce({}){|memo, first, second|memo[first] = second;memo}
print ret # => output {1=>4, 2=>2, 3=>3, 4=>1}
# File lib/open_classes/array/together_reduce.rb, line 43
def together_reduce(init = nil)
  if_not_contain_array_rails_type_error
  memo = initial_memo init
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    memo = instance_eval "yield(memo, #{eval_each_str})"
  end
  memo
end
together_reverse() click to toggle source

Arrays bulk reverse.

together_reverse has alias :treverse

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_reverse
print ret # => [[2, 1], [6, 5]]
print lists # => [[1, 2], [5, 6]]

one empty case

lists = [[1, 2], []]
ret = lists.together_reverse
print ret # => [[2, 1], []]
print lists # => [[1, 2], []]
# File lib/open_classes/array/together_reverse.rb, line 25
def together_reverse
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.reverse }
end
Also aliased as: treverse
together_reverse!() click to toggle source

Arrays bulk reverse!.

together_reverse! has alias :treverse!

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_reverse!
print ret # => [[2, 1], [6, 5]]
print lists # => [[2, 1], [6, 5]]

one empty case

lists = [[1, 2], []]
ret = lists.together_reverse!
print ret # => [[2, 1], []]
print lists # => [[2, 1], []]
# File lib/open_classes/array/together_reverse.rb, line 46
def together_reverse!
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.reverse! }
end
Also aliased as: treverse!
together_sample(count = nil) click to toggle source

Arrays bulk sample.

together_sample has alias :tsample

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_sample
print ret # => [1 or 2, 5 or 6]

empty case

lists = [[], []]
ret = lists.together_sample
print ret # => [nil, nil]

not empty case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_sample 2
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]]

not empty case with args

lists = [[], []]
ret = lists.together_sample 2
print ret # => [[], []]

not empty, over size case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_sample 3
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]]
# File lib/open_classes/array/together_sample.rb, line 39
def together_sample(count = nil)
  if_not_contain_array_rails_type_error
  if count.nil?
    reduce([]) { |ret, list|ret << list.sample }
  else
    reduce([]) { |ret, list|ret << list.sample(count) }
  end
end
Also aliased as: tsample
together_select() click to toggle source

Arrays loop together select.

together_select has aliases [:tselect, :together_find_all, :tfindall]

if you want to single Array return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_select{|first, second|first == second}
print ret # => output  [[2, 3], [2, 3]]

if you want to multi Array return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_select{|first, second|[first.odd?, second.even?]}
print ret # => output  [[1, 3], [4, 2]]
# File lib/open_classes/array/together_select.rb, line 25
def together_select
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_select(ret, each_ret, i)
  end
  ret
end
together_shift(count = nil) click to toggle source

Arrays bulk shift.

together_shift has alias :tshift

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_shift
print ret # => [1, 5]
print lists # => [2, 6]

empty case

lists = [[], []]
ret = lists.together_shift
print ret # => [nil, nil]
print lists # => [[], []]

not empty case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_shift 2
print ret # => [[1, 2], [5, 6]]
print lists # => [[], []]

not empty case with args

lists = [[], []]
ret = lists.together_shift 2
print ret # => [[], []]
print lists # => [[], []]
# File lib/open_classes/array/together_shift.rb, line 37
def together_shift(count = nil)
  if_not_contain_array_rails_type_error
  if count.nil?
    reduce([]) { |ret, list|ret << list.shift }
  else
    reduce([]) { |ret, list|ret << list.shift(count) }
  end
end
Also aliased as: tshift
together_shuffle(count = nil) click to toggle source

Arrays bulk shuffle.

together_shuffle has alias :tshuffle

lists = [[1, 2], [5, 6]]
ret = lists.together_shuffle
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]]
# File lib/open_classes/array/together_shuffle.rb, line 17
def together_shuffle(count = nil)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.shuffle }
end
Also aliased as: tshuffle
together_slice(*args) click to toggle source

Arrays bulk slice.

together_slice has alias :tslice

Examples

single args case

lists = [[*1..5], [*6..10]]
ret = lists.together_slice 2
print ret # => [3, 8]

multi args case

lists = [[*1..5], [*6..10]]
ret = lists.together_slice 2, 2
print ret # => [[3, 4], [8, 9]]

range args case

lists = [[*1..5], [*6..10]]
ret = lists.together_slice (2..3)
print ret # => [[3, 4], [8, 9]]
# File lib/open_classes/array/together_slice.rb, line 32
def together_slice(*args)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.slice(*args) }
end
Also aliased as: tslice
together_with_index() click to toggle source

Arrays loop together with index.

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_with_index do |first, second, index|
  print "#{index.to_s}:#{first}:#{second}\n"  # => output 0:one:1, 1:two:2, 2:three:3
end
# File lib/open_classes/array/together_with_index.rb, line 17
def together_with_index
  if_not_contain_array_rails_type_error
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i, true
    instance_eval "yield(#{eval_each_str})"
  end
end
tpop(count = nil)
Alias for: together_pop
treverse()
Alias for: together_reverse
treverse!()
Alias for: together_reverse!
tsample(count = nil)
Alias for: together_sample
tshift(count = nil)
Alias for: together_shift
tshuffle(count = nil)
Alias for: together_shuffle
tslice(*args)
Alias for: together_slice
uniq_size() click to toggle source

return uniq size

Example

([*1..6] + [2,3]).uniq_size # => 6
[*1..6].uniq_size # => 6
[].uniq_size # => 0
# File lib/open_classes/array/uniq_size.rb, line 13
def uniq_size
  uniq.size
end

Private Instance Methods

set_together_each_return_map(ret, each_ret, index) click to toggle source
# File lib/open_classes/array/together_map.rb, line 75
def set_together_each_return_map(ret, each_ret, index)
  if together_return_multi?(each_ret)
    size.times { |i|ret << [] } if index == 0
    (0..(size - 1)).each { |i|ret[i] << each_ret[i] }
  else
    ret << each_ret
  end
  ret
end
set_together_each_return_select(ret, each_ret, index) click to toggle source
# File lib/open_classes/array/together_select.rb, line 38
def set_together_each_return_select(ret, each_ret, index)
  unless together_return_multi?(each_ret)
    tmp_each_ret = []
    size.times { tmp_each_ret << each_ret }
    each_ret = tmp_each_ret
  end
  size.times { |i|ret << [] } if index == 0
  (0..(size - 1)).each { |i|ret[i] << self[i][index] if each_ret[i] }
  ret
end