### Home Classes Methods

### In Files

- lib/facets/random.rb

### Methods

- #at_rand
- #at_rand!
- #pick
- #pick!
- #rand_index
- #rand_subset
- #shuffle
- #shuffle!

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- Random
- Random::ArrayExtensions
- Random::HashExtensions
- Random::IntegerExtensions
- Random::NumericExtensions
- Random::RangeExtensions
- Random::StringExtensions
- Random::StringExtensions::Self
- FileUtils
- FileUtils::DryRun
- FileUtils::NoWrite
- FileUtils::Verbose
- Digest
- Digest::Class
- Digest::Instance
- Multiton
- Multiton::Inclusive
- Multiton::MetaMethods
- URI
- URI::Hash
- URI::Kernel
- Argvector
- Argvector
- ERB
- ERB::OpenTemplate
- Enumerable
- Enumerable::Arguments
- GetoptLong
- GetoptLong::DSL
- Memoizable
- Memoizable::Copy
- Numeric
- Numeric::Multipliers
- Object
- Object::ArgVector
- Timer
- Timer::Dummy
- Array
- BasicObject
- CGI
- Cloneable
- Continuation
- Date
- DateTime
- Equitable
- File
- Find
- Hash
- Instantiable
- Integer
- Interval
- Kernel
- Math
- Module
- Net
- NilClass
- NullClass
- OpEsc
- OpenStruct
- Pathname
- Platform
- Range
- RbConfig
- Set
- Shellwords
- String
- StringScanner
- Time
- Tuple
- YAML
- Zlib

No matching classes.

# Random::ArrayExtensions

### Public Instance Methods

at_rand() click to toggle source

Return a random element from the array.

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

    # File lib/facets/random.rb, line 128
    def at_rand
      at(Random.number(size))
    end

at_rand!() click to toggle source

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]

    # File lib/facets/random.rb, line 139
    def at_rand!
      return delete_at( Random.number( size ) )
    end

pick(n=nil) click to toggle source

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

    # File lib/facets/random.rb, line 145
    def pick(n=nil)
      if n
        a = self.dup
        a.pick!(n)
      else
        at(Random.number(size))
      end
    end

pick!(n=nil) click to toggle source

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

    # File lib/facets/random.rb, line 156
    def pick!(n=nil)
      if n
        if n > self.size
          r = self.dup
          self.replace([])
          r
        else
          r = []
          n.times { r << delete_at(Random.number(size)) }
          r
        end
      else
        delete_at(Random.number(size))
      end
    end

rand_index() click to toggle source

Random index.

    # File lib/facets/random.rb, line 174
    def rand_index
      Random.number(size)
    end

rand_subset( number=nil, exclusive=true ) click to toggle source

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]

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

shuffle() click to toggle source

Randomize the order of an array.

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

    # File lib/facets/random.rb, line 209
    def shuffle
      dup.shuffle!
      #sort_by{Random.number}
    end

shuffle!() click to toggle source

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

    # File lib/facets/random.rb, line 223
    def shuffle!
      s = size
      each_index do |j|
        i = Random.number(s-j)
        #self[j], self[j+i] = self[j+i], self[j]
        tmp = self[j]
        self[j] = self[j+i]
        self[j+i] = tmp
      end
      self
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.