Module: Random::Array

Return a random element of the array.

  [1, 2, 3, 4].at_rand           #=> 2
  [1, 2, 3, 4].at_rand           #=> 4

[Source]

     # File lib/more/facets/random.rb, line 107
107:     def at_rand
108:       at(Random.number(size))
109:     end

at_rand!()

Same as at_rand, but acts in place removing a random element from the array.

  a = [1,2,3,4]
  a.at_rand!       #=> 2
  a                #=> [1,3,4]

[Source]

     # File lib/more/facets/random.rb, line 118
118:     def at_rand!
119:       return delete_at( Random.number( size ) )
120:     end

pick(n=nil)

Similar to at_rand, but will return an array of randomly picked exclusive elements if given a number.

[Source]

     # File lib/more/facets/random.rb, line 124
124:     def pick(n=nil)
125:       if n
126:         a = self.dup
127:         a.pick!(n)
128:       else
129:         at(Random.number(size))
130:       end
131:     end

pick!(n=nil)

Similar to at_rand!, but given a number will return an array of exclusive elements.

[Source]

     # File lib/more/facets/random.rb, line 135
135:     def pick!(n=nil)
136:       if n
137:         if n > self.size
138:           r = self.dup
139:           self.replace([])
140:           r
141:         else
142:           r = []
143:           n.times { r << delete_at(Random.number(size)) }
144:           r
145:         end
146:       else
147:         delete_at(Random.number(size))
148:       end
149:     end

rand_index()

Random index.

[Source]

     # File lib/more/facets/random.rb, line 153
153:     def rand_index
154:       Random.number(size)
155:     end

rand_subset( number=nil, exclusive=true )

Returns a random subset of an Array. If a number of elements is specified then returns that number of elements, otherwise returns a random number of elements upto the size of the Array.

By defualt the returned values are exclusive of each other, but if exclusive is set to false, the same values can be choosen more than once.

When exclusive is true (the default) and the number given is greater than the size of the array, then all values are returned.

  [1, 2, 3, 4].rand_subset(1)        #=> [2]
  [1, 2, 3, 4].rand_subset(4)        #=> [2, 1, 3, 4]
  [1, 2, 3, 4].rand_subset           #=> [1, 3, 4]
  [1, 2, 3, 4].rand_subset           #=> [2, 3]

[Source]

     # File lib/more/facets/random.rb, line 175
175:     def rand_subset( number=nil, exclusive=true )
176:       number = Random.number(size) unless number
177:       number = number.to_int
178:       #return self.dup if (number >= size and exlusive)
179:       return sort_by{rand}.slice(0,number) if exclusive
180:       ri =[]; number.times { |n| ri << Random.number(size) }
181:       return values_at(*ri)
182:     end

shuffle()

Randomize the order of an array.

  [1,2,3,4].shuffle  #=> [2,4,1,3]

[Source]

     # File lib/more/facets/random.rb, line 188
188:     def shuffle
189:       dup.shuffle!
190:       #sort_by{Random.number}
191:     end

shuffle!()

As with shuffle but modifies the array in place. The algorithm used here is known as a Fisher-Yates shuffle.

  a = [1,2,3,4]
  a.shuffle!
  a  #=> [2,4,1,3]

CREDIT Niel Spring

[Source]

     # File lib/more/facets/random.rb, line 202
202:     def shuffle!
203:       s = size
204:       each_index do |j|
205:         i = Random.number(s-j)
206:         #self[j], self[j+i] = self[j+i], self[j]
207:         tmp = self[j]
208:         self[j] = self[j+i]
209:         self[j+i] = tmp
210:       end
211:       self
212:     end

Methods

Public Instance methods