[swift] Apple의 Swift 언어에서 난수를 어떻게 생성합니까?

편집 : Swift 3.0 업데이트

arc4randomSwift에서는 잘 작동하지만 기본 기능은 32 비트 정수 유형 ( IntiPhone 5S 및 최신 Mac에서는 64 비트)으로 제한됩니다. 다음은 정수 리터럴로 표현할 수있는 임의의 숫자 유형에 대한 일반 함수입니다.

public func arc4random<T: ExpressibleByIntegerLiteral>(_ type: T.Type) -> T {
    var r: T = 0
    arc4random_buf(&r, MemoryLayout<T>.size)
    return r
}

이 새로운 일반 함수를 사용하여 확장 UInt64하고 경계 인수를 추가하고 모듈러스 바이어스를 완화 할 수 있습니다 . (이것은 arc4random.c 에서 똑바로 들어 올려집니다 )

public extension UInt64 {
    public static func random(lower: UInt64 = min, upper: UInt64 = max) -> UInt64 {
        var m: UInt64
        let u = upper - lower
        var r = arc4random(UInt64.self)

        if u > UInt64(Int64.max) {
            m = 1 + ~u
        } else {
            m = ((max - (u * 2)) + 1) % u
        }

        while r < m {
            r = arc4random(UInt64.self)
        }

        return (r % u) + lower
    }
}

이를 통해 우리는 Int64오버플로를 처리하면서 동일한 인수로 확장 할 수 있습니다 .

public extension Int64 {
    public static func random(lower: Int64 = min, upper: Int64 = max) -> Int64 {
        let (s, overflow) = Int64.subtractWithOverflow(upper, lower)
        let u = overflow ? UInt64.max - UInt64(~s) : UInt64(s)
        let r = UInt64.random(upper: u)

        if r > UInt64(Int64.max)  {
            return Int64(r - (UInt64(~lower) + 1))
        } else {
            return Int64(r) + lower
        }
    }
}

가족을 완성하려면 …

private let _wordSize = __WORDSIZE

public extension UInt32 {
    public static func random(lower: UInt32 = min, upper: UInt32 = max) -> UInt32 {
        return arc4random_uniform(upper - lower) + lower
    }
}

public extension Int32 {
    public static func random(lower: Int32 = min, upper: Int32 = max) -> Int32 {
        let r = arc4random_uniform(UInt32(Int64(upper) - Int64(lower)))
        return Int32(Int64(r) + Int64(lower))
    }
}

public extension UInt {
    public static func random(lower: UInt = min, upper: UInt = max) -> UInt {
        switch (_wordSize) {
            case 32: return UInt(UInt32.random(UInt32(lower), upper: UInt32(upper)))
            case 64: return UInt(UInt64.random(UInt64(lower), upper: UInt64(upper)))
            default: return lower
        }
    }
}

public extension Int {
    public static func random(lower: Int = min, upper: Int = max) -> Int {
        switch (_wordSize) {
            case 32: return Int(Int32.random(Int32(lower), upper: Int32(upper)))
            case 64: return Int(Int64.random(Int64(lower), upper: Int64(upper)))
            default: return lower
        }
    }
}

결국, 우리는 마침내 다음과 같이 할 수 있습니다 :

let diceRoll = UInt64.random(lower: 1, upper: 7)

답변

// Generates integers starting with 0 up to, and including, 10
Int.random(in: 0 ... 10)

func randomInt(min: Int, max: Int) -> Int {
    return min + Int(arc4random_uniform(UInt32(max - min + 1)))
}

var k: Int = random() % 10;

GKRandomSource.sharedRandom().nextInt()

GKRandomSource.sharedRandom().nextIntWithUpperBound(6)

let d6 = GKRandomDistribution.d6()
d6.nextInt()

let randomNumber = arc4random()