私はSwiftブックが乱数ジェネレーターの実装を提供していることを理解しています。この実装を自分のプログラムにコピーして貼り付けるのがベストプラクティスですか？または、これを使用して現在使用できるライブラリはありますか？

Swift 4.2以降

Xcode 10に同梱されているSwift 4.2では、多くのデータ型に使用できる新しい使いやすいランダム関数が導入されています。random()数値型に対してメソッドを呼び出すことができます。

let randomInt = Int.random(in: 0..<6)
let randomDouble = Double.random(in: 2.71828...3.14159)
let randomBool = Bool.random()

0〜n arc4random_uniform(n)-1のランダムな整数に使用します。

let diceRoll = Int(arc4random_uniform(6) + 1)

結果をIntにキャストして、varを明示的に入力する必要がないようにしますUInt32（Swiftyではないようです）。

編集： 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)

Swift 4.2用に編集

Swift 4.2以降、インポートされたC関数arc4random_uniform（）を使用する代わりに、Swift独自のネイティブ関数を使用できるようになりました。

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

を使用random(in:)して、他のプリミティブ値のランダムな値を取得することもできます。Int、Double、Float、Boolなどです。

Swiftバージョン<4.2

このメソッドはInt、指定された最小値と最大値の間のランダムな値を生成します

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

私はこのコードを使用しました：

var k: Int = random() % 10;

iOS 9では、新しいGameplayKitクラスを使用して、さまざまな方法で乱数を生成できます。

選択できるソースタイプは4つあります。一般的なランダムソース（名前なし、システムが選択するもの）、線形合同、ARC4、およびMersenne Twisterです。これらはランダムな整数、浮動小数点数、ブール値を生成できます。

最も単純なレベルでは、次のようにシステムの組み込みランダムソースから乱数を生成できます。

GKRandomSource.sharedRandom().nextInt()

これにより、-2,147,483,648〜2,147,483,647の数値が生成されます。0と上限（排他的）の間の数値が必要な場合は、次のようにします。

GKRandomSource.sharedRandom().nextIntWithUpperBound(6)

GameplayKitには、サイコロを操作するための便利なコンストラクタがいくつか組み込まれています。たとえば、次のように6面のサイコロを振ることができます。

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

さらに、GKShuffledDistributionなどを使用してランダム分布を形成できます。これにはもう少し説明が必要ですが、興味がある場合はGameplayKit乱数に関するチュートリアルを読むことができます。

Cで行うのと同じ方法で行うことができます。

let randomNumber = arc4random()

randomNumberタイプUInt32（32ビット符号なし整数）であると推定されます

使用する arc4random_uniform()

使用法：

arc4random_uniform(someNumber: UInt32) -> UInt32

これは、あなたの範囲内のランダムな整数与え0にしますsomeNumber - 1。

の最大値UInt32は4,294,967,295です（つまり、2^32 - 1）です。

例：

• コインフリップ

  let flip = arc4random_uniform(2) // 0 or 1

• ダイスロール

  let roll = arc4random_uniform(6) + 1 // 1...6

• 10月のランダムな日

  let day = arc4random_uniform(31) + 1 // 1...31

• 1990年代のランダムな年

  let year = 1990 + arc4random_uniform(10)

一般的な形式：

let number = min + arc4random_uniform(max - min + 1)

ここnumberでmax、、、およびminですUInt32。

どうですか...

arc4random（）

また、0から2 ^ 32-1 arc4random()を生成するを使用して乱数を取得することもできUInt32ます。したがって、0との間の乱数を取得するにはx-1、それを除算してx、残りを取得します。または言い換えると、剰余演算子（％）を使用します。

let number = arc4random() % 5 // 0...4

ただし、これはわずかなモジュロバイアスを生成するため（こことここも参照）、そのため、これarc4random_uniform()が推奨されます。

変換 Int

通常、との間Intで前後に変換するために、このようなことを行うと問題ありませんUInt32。

let number: Int = 10
let random = Int(arc4random_uniform(UInt32(number)))

問題は、しかし、それはあるInt範囲有する-2,147,483,648...2,147,483,64732ビットシステム上の範囲-9,223,372,036,854,775,808...9,223,372,036,854,775,80764ビットシステムです。これをのUInt32範囲と比較してください0...4,294,967,295。手段符号なし。UUInt32

次のエラーを検討してください。

UInt32(-1) // negative numbers cause integer overflow error
UInt32(4294967296) // numbers greater than 4,294,967,295 cause integer overflow error

したがって、入力パラメーターが範囲内にUInt32あり、その範囲外の出力も必要ないことを確認する必要があります。

10（0-9）の乱数の例。

import UIKit

let randomNumber = Int(arc4random_uniform(10))

非常に簡単なコード-シンプルで短い。

rand()ランダムなCIntを取得するために使用することができました。次のようなものを使用して、それをIntにすることができます。

let myVar: Int = Int(rand())

お気に入りのCランダム関数を使用して、必要に応じて値をIntに変換できます。

@jstnの答えは良いですが、少し冗長です。Swiftはプロトコル指向言語として知られているため、プロトコル拡張のデフォルト実装を追加することで、整数ファミリのすべてのクラスに定型コードを実装しなくても同じ結果を得ることができます。

public extension ExpressibleByIntegerLiteral {
    public static func arc4random() -> Self {
        var r: Self = 0
        arc4random_buf(&r, MemoryLayout<Self>.size)
        return r
    }
}

今私たちはできる：

let i = Int.arc4random()
let j = UInt32.arc4random()

他のすべての整数クラスは問題ありません。

でスウィフト4.2あなたは呼び出すことで乱数を生成することができrandom()、必要な数値どんな種類のメソッドを使用したい範囲を提供します。たとえば、これは、両端を含む1〜9の範囲の乱数を生成します。

let randInt = Int.random(in: 1..<10)

他のタイプとも

let randFloat = Float.random(in: 1..<20)
let randDouble = Double.random(in: 1...30)
let randCGFloat = CGFloat.random(in: 1...40)

これはうまく機能するライブラリです https://github.com/thellimist/SwiftRandom

public extension Int {
    /// SwiftRandom extension
    public static func random(lower: Int = 0, _ upper: Int = 100) -> Int {
        return lower + Int(arc4random_uniform(UInt32(upper - lower + 1)))
    }
}

public extension Double {
    /// SwiftRandom extension
    public static func random(lower: Double = 0, _ upper: Double = 100) -> Double {
        return (Double(arc4random()) / 0xFFFFFFFF) * (upper - lower) + lower
    }
}

public extension Float {
    /// SwiftRandom extension
    public static func random(lower: Float = 0, _ upper: Float = 100) -> Float {
        return (Float(arc4random()) / 0xFFFFFFFF) * (upper - lower) + lower
    }
}

public extension CGFloat {
    /// SwiftRandom extension
    public static func random(lower: CGFloat = 0, _ upper: CGFloat = 1) -> CGFloat {
        return CGFloat(Float(arc4random()) / Float(UINT32_MAX)) * (upper - lower) + lower
    }
}

 let MAX : UInt32 = 9
 let MIN : UInt32 = 1

    func randomNumber()
{
    var random_number = Int(arc4random_uniform(MAX) + MIN)
    print ("random = ", random_number);
}

Swiftブックの乱数ジェネレーターの例は線形合同ジェネレーター（LCG）であるという既存の回答に追加したいと思います。これは厳格に制限されたものであり、ランダム性の品質が重要な簡単な例を除いてはなりません。まったく関係ありません。また、LCGを暗号化の目的で使用することはできません。

arc4random()ははるかに優れており、ほとんどの目的に使用できますが、暗号化の目的には使用しないでください。

暗号的に安全であることが保証されているものが必要な場合は、を使用してくださいSecCopyRandomBytes()。乱数ジェネレーターを何かに組み込んだ場合、誰かが暗号化の目的（パスワード、キー、ソルトの生成など）でそれを（誤）使用する可能性があることに注意してSecCopyRandomBytes()ください。必要がない場合でも、とにかく使用を検討する必要があります。それはかなり必要です。

Swift 4.2以降

新しいAPIのセットがあります。

let randomIntFrom0To10 = Int.random(in: 0 ..< 10)
let randomDouble = Double.random(in: 1 ... 10)

• すべての数値型に、を使用するrandom(in:)メソッドが追加されましたrange。

• その範囲に均一に分布した数を返します。

TL; DR

さて、「古き良き」古い方法の何が問題になっていますか？

1. インポートされたC API を使用する必要があります（プラットフォーム間で異なります）。

2. そして更に...

ランダムはそのランダムではないとあなたに言ったらどうなりますか？

あなたが使用している場合arc4random() （剰余を計算する）のようなarc4random() % aNumber、結果がされていない均一の間に分布0してaNumber。Moduloバイアスと呼ばれる問題があります。

モジュロバイアス

通常、関数は0とMAXの 間の乱数を生成します（型などによって異なります）。簡単な例を簡単に説明すると、最大数はで7あり、範囲内の乱数0 ..< 2 （または、間隔[0、3）を希望する場合）に関心があるとします。

個々の数値の確率は次のとおりです。

• 0：3/8 = 37.5％
• 1：3/8 = 37.5％
• 2：2/8 = 25％

つまり、最終的には2よりも0または1になる可能性が高くなります。もちろん、これは非常に単純化されており、MAXの数値ははるかに高く、より「公平」であることに注意してください。

この問題は、によって対処されるランダム統一- SE-0202でスウィフト4.2

Xcodeの一部のバージョンでarc4Random_uniform（）がない場合（7.1では実行されますが、自動補完されません）。代わりにこれを行うことができます。

0〜5の乱数を生成します。最初

import GameplayKit

その後

let diceRoll = GKRandomSource.sharedRandom().nextIntWithUpperBound(6)

var randomNumber = Int(arc4random_uniform(UInt32(5)))

ここで5は、乱数が0から4まで生成されることを確認します。それに応じて値を設定できます。

Swift 4.2

さようならFoundation C libをインポートする arc4random_uniform()

// 1  
let digit = Int.random(in: 0..<10)

// 2
if let anotherDigit = (0..<10).randomElement() {
  print(anotherDigit)
} else {
  print("Empty range.")
}

// 3
let double = Double.random(in: 0..<1)
let float = Float.random(in: 0..<1)
let cgFloat = CGFloat.random(in: 0..<1)
let bool = Bool.random()

1. random（in :)を使用して、範囲からランダムな数字を生成します。
2. randomElement（）は、範囲が空の場合はnilを返すため、返されたIntをラップ解除しますか？としましょう。
3. random（in :)を使用してランダムなDouble、FloatまたはCGFloatを生成し、random（）を使用してランダムなBoolを返します。

もっと@ publicdomainq.net

次のコードは、0〜255の安全な乱数を生成します。

extension UInt8 {
  public static var random: UInt8 {
    var number: UInt8 = 0
    _ = SecRandomCopyBytes(kSecRandomDefault, 1, &number)
    return number
  }
}

次のように呼び出します。

print(UInt8.random)

数値が大きいほど複雑になります。
これは私が思いつくことができる最高のものです：

extension UInt16 {
  public static var random: UInt16 {
    let count = Int(UInt8.random % 2) + 1
    var numbers = [UInt8](repeating: 0, count: 2)
    _ = SecRandomCopyBytes(kSecRandomDefault, count, &numbers)
    return numbers.reversed().reduce(0) { $0 << 8 + UInt16($1) }
  }
}

extension UInt32 {
  public static var random: UInt32 {
    let count = Int(UInt8.random % 4) + 1
    var numbers = [UInt8](repeating: 0, count: 4)
    _ = SecRandomCopyBytes(kSecRandomDefault, count, &numbers)
    return numbers.reversed().reduce(0) { $0 << 8 + UInt32($1) }
  }
}

これらのメソッドは、追加の乱数をUInt8使用して、乱数の作成に使用されるの数を決定します。最後の行は、変換[UInt8]しますUInt16か、UInt32ます。

最後の2つがまだ本当にランダムであるかどうかはわかりませんが、好みに応じて調整できます。

Swift 4.2

Swift 4.2の標準ライブラリには、ネイティブでかなりフル機能の乱数APIが含まれています。（Swift EvolutionプロポーザルSE-0202）

let intBetween0to9 = Int.random(in: 0...9) 
let doubleBetween0to1 = Double.random(in: 0...1)

すべての数値タイプには、範囲を受け取り、指定された範囲の乱数を返す静的な乱数（in :)があります。

スウィフト4.2、Xcodeの10.1。

iOS、macOS、tvOSの場合、Xcodeのフレームワークでシステム全体のランダムソースを使用できますGameKit。ここではGKRandomSource、そのsharedRandom()クラスメソッドでクラスを見つけることができます：

import GameKit

let number: [Int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

func randomGenerator() -> Int {
    let random = GKRandomSource.sharedRandom().nextInt(upperBound: number.count)
    return number[random]
}
randomGenerator()

またはrandomElement()、コレクションのランダムな要素を返すメソッドを使用します。

let number: [Int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

let randomNumber = number.randomElement()!
print(randomNumber)

次のGeneratorOfように使用できます：

var fibs = ArraySlice([1, 1])
var fibGenerator = GeneratorOf{
    _ -> Int? in
    fibs.append(fibs.reduce(0, combine:+))
    return fibs.removeAtIndex(0)
}

println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())

私はこのコードを使用して乱数を生成します：

//
//  FactModel.swift
//  Collection
//
//  Created by Ahmadreza Shamimi on 6/11/16.
//  Copyright © 2016 Ahmadreza Shamimi. All rights reserved.
//

import GameKit

struct FactModel {

    let fun  = ["I love swift","My name is Ahmadreza","I love coding" ,"I love PHP","My name is ALireza","I love Coding too"]


    func getRandomNumber() -> String {

        let randomNumber  = GKRandomSource.sharedRandom().nextIntWithUpperBound(fun.count)

        return fun[randomNumber]
    }
}

細部

xCode 9.1、Swift 4

数学指向のソリューション（1）

import Foundation

class Random {

    subscript<T>(_ min: T, _ max: T) -> T where T : BinaryInteger {
        get {
            return rand(min-1, max+1)
        }
    }
}

let rand = Random()

func rand<T>(_ min: T, _ max: T) -> T where T : BinaryInteger {
    let _min = min + 1
    let difference = max - _min
    return T(arc4random_uniform(UInt32(difference))) + _min
}

ソリューションの使用法（1）

let x = rand(-5, 5)       // x = [-4, -3, -2, -1, 0, 1, 2, 3, 4]
let x = rand[0, 10]       // x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

プログラマー向けソリューション（2）

ここに数学指向のソリューション（1）コードを追加することを忘れないでください

import Foundation

extension CountableRange where Bound : BinaryInteger {

    var random: Bound {
        return rand(lowerBound-1, upperBound)
    }
}

extension CountableClosedRange where Bound : BinaryInteger {

    var random: Bound {
        return rand[lowerBound, upperBound]
    }
}

ソリューションの使い方（2）

let x = (-8..<2).random           // x = [-8, -7, -6, -5, -4, -3, -2, -1, 0, 1]
let x = (0..<10).random           // x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
let x = (-10 ... -2).random       // x = [-10, -9, -8, -7, -6, -5, -4, -3, -2]

完全なサンプル

ことを忘れてはいけない溶液（1）及び溶液（2）のコードを追加し、ここで

private func generateRandNums(closure:()->(Int)) {

    var allNums = Set<Int>()
    for _ in 0..<100 {
        allNums.insert(closure())
    }
    print(allNums.sorted{ $0 < $1 })
}

generateRandNums {
    (-8..<2).random
}

generateRandNums {
    (0..<10).random
}

generateRandNums {
    (-10 ... -2).random
}

generateRandNums {
    rand(-5, 5)
}
generateRandNums {
    rand[0, 10]
}

サンプル結果