Skip to content

Instantly share code, notes, and snippets.

@mattt
Last active August 26, 2019 15:37
  • Star 34 You must be signed in to star a gist
  • Fork 3 You must be signed in to fork a gist
Star You must be signed in to star a gist
Save mattt/f2ee2eed3570d1a9d644 to your computer and use it in GitHub Desktop.
import Darwin
extension Int {
static func random() -> Int {
return Int(arc4random())
}
static func random(range: Range<Int>) -> Int {
return Int(arc4random_uniform(UInt32(range.endIndex - range.startIndex))) + range.startIndex
}
}
extension Double {
static func random() -> Double {
return drand48()
}
}
@gampleman
Copy link

A RandomInstance (or Arbitrary) protocol would be nice, which would mean any type could implement a random method to get a random instance of the type (useful for things like quick check).

@rparada
Copy link

rparada commented Jan 3, 2015

Here are some you can add to shuffle array elements using your extension for random number generation.

extension Array {
    /**
     * Shuffles the array elements.
     */
    mutating func shuffle() {
        if count > 1 {
            let iLast = count - 1
            for i in 0..<iLast {
                let iRandom = Int.random(i...iLast)
                let temp = self[i]
                self[i] = self[iRandom]
                self[iRandom] = temp
            }
        }
    }

    /**
     * Returns a copy of the array with the elements shuffled.
     */
    func shuffled() -> [T] {
        var newArray = [T](self)
        newArray.shuffle()
        return newArray
    }
}

@lchenay
Copy link

lchenay commented Jul 8, 2015

If someone use this code, replace return Int(arc4random()) by `return Int(arc4random_uniform(UInt32(Int.max)))``
arc4random() return UInt32 from 0 to UInt32.max. Not all the range are compatible with Int and will result in a EXC_BAD_INSTRUCTION

@callmewhy
Copy link

@lchenay is right

@MatrixSenpai
Copy link

MatrixSenpai commented May 25, 2016

Note iLast can be left out in favor of ..<count.
Same in Int.random(i..<count).
Also note [T] is deprecated in favor of [Element]
For sets

extension Set {
    mutating func shuffle() {
        if count > 1 {
            for i in 0..<count {
                let r = Int.random(i..<count)
                let temp = self[self.startIndex.advancedBy(r)]
                self.removeAtIndex(self.startIndex.advancedBy(r))
                self.insert(temp)
            }
        }
    }
}

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment