Swift aléatoire flotter entre 0 et 1

C'est l'extension pour nombres aléatoires de Int, Double, Float, CGFloat

Swift 3 & 4 syntaxe

import Foundation
import CoreGraphics
//MARK: Int Extension

public extension Int {
///Returns a random Int point number between 0 and Int.max.
    public static var random: Int {
return Int.random(n: Int.max)
}
///Random integer between 0 and n-1.
    ///
    ///- Parameter n:  Interval max
    ///- Returns:      Returns a random Int point number between 0 and n max
    public static func random(n: Int) -> Int {
return Int(arc4random_uniform(UInt32(n)))
}
/// Random integer between min and max
    ///
    ///- Parameters:
    ///  - min:    Interval minimun
    ///  - max:    Interval max
    ///- Returns:  Returns a random Int point number between 0 and n max
    public static func random(min: Int, max: Int) -> Int {
return Int.random(n: max - min + 1) + min
}
}
//MARK: Double Extension

public extension Double {
///Returns a random floating point number between 0.0 and 1.0, inclusive.
    public static var random: Double {
return Double(arc4random()) / 0xFFFFFFFF
}
///Random double between 0 and n-1.
    ///
    ///- Parameter n:  Interval max
    ///- Returns:      Returns a random double point number between 0 and n max
    public static func random(min: Double, max: Double) -> Double {
return Double.random * (max - min) + min
}
}
//MARK: Float Extension

public extension Float {
///Returns a random floating point number between 0.0 and 1.0, inclusive.
    public static var random: Float {
return Float(arc4random()) / 0xFFFFFFFF
}
///Random float between 0 and n-1.
    ///
    ///- Parameter n:  Interval max
    ///- Returns:      Returns a random float point number between 0 and n max
    public static func random(min: Float, max: Float) -> Float {
return Float.random * (max - min) + min
}
}
//MARK: CGFloat Extension

public extension CGFloat {
///Randomly returns either 1.0 or -1.0.
    public static var randomSign: CGFloat {
return (arc4random_uniform(2) == 0) ? 1.0 : -1.0
}
///Returns a random floating point number between 0.0 and 1.0, inclusive.
    public static var random: CGFloat {
return CGFloat(Float.random)
}
///Random CGFloat between 0 and n-1.
    ///
    ///- Parameter n:  Interval max
    ///- Returns:      Returns a random CGFloat point number between 0 and n max
    public static func random(min: CGFloat, max: CGFloat) -> CGFloat {
return CGFloat.random * (max - min) + min
}
}

Utilisation :

let randomNumDouble  = Double.random(min: 0.00, max: 23.50)
let randomNumInt     = Int.random(min: 56, max: 992)
let randomNumFloat   = Float.random(min: 6.98, max: 923.09)
let randomNumCGFloat = CGFloat.random(min: 6.98, max: 923.09)

swift 4.2 :

let randomFloat = Float.random(in: 0..<1)

Ci-dessous est une extension sur le IntervalType type pour ce faire:

extension IntervalType {
public func random() -> Bound {
let range = (self.end as! Double) - (self.start as! Double)
let randomValue = (Double(arc4random_uniform(UINT32_MAX)) / Double(UINT32_MAX)) * range + (self.start as! Double)
return randomValue as! Bound
}
}

Avec cette extension, vous pouvez utiliser l'intervalle de syntaxe pour la génération d'un intervalle et ensuite obtenir une valeur aléatoire dans l'intervalle:

(0.0...1.0).random()

Plus

Si vous cherchez à faire de même pour Ints, alors vous pouvez utiliser l'extension suivante sur la CollectionType protocole:

extension CollectionType {
public func random() -> Self._Element {
if let startIndex = self.startIndex as? Int {
let start = UInt32(startIndex)
let end = UInt32(self.endIndex as! Int)
return self[Int(arc4random_uniform(end - start) + start) as! Self.Index]
}
var generator = self.generate()
var count = arc4random_uniform(UInt32(self.count as! Int))
while count > 0 {
generator.next()
count = count - 1
}
return generator.next() as! Self._Element
}
}

Ints n'utilisez pas le IntervalType. Ils utilisent Range à la place. L'avantage de le faire sur le CollectionType type est qu'il est automatiquement reporté à l' Dictionary et Array types.

Exemples:

(0...10).random()               //Ex: 6
["A", "B", "C"].random()        //Ex: "B"
["X":1, "Y":2, "Z":3].random()  // Ex: (.0: "Y", .1: 2)

drand48()

Dans le cas où vous avez besoin d' [Double]. Entre 0 et 1. C'est tout.

Détails

Xcode: 9.2, Swift 4

Solution

extension BinaryInteger {
static func rand(_ min: Self, _ max: Self) -> Self {
let _min = min
let difference = max+1 - _min
return Self(arc4random_uniform(UInt32(difference))) + _min
}
}
extension BinaryFloatingPoint {
private func toInt() -> Int {
//https://stackoverflow.com/q/49325962/4488252
        if let value = self as? CGFloat {
return Int(value)
}
return Int(self)
}
static func rand(_ min: Self, _ max: Self, precision: Int) -> Self {
if precision == 0 {
let min = min.rounded(.down).toInt()
let max = max.rounded(.down).toInt()
return Self(Int.rand(min, max))
}
let delta = max - min
let maxFloatPart = Self(pow(10.0, Double(precision)))
let maxIntegerPart = (delta * maxFloatPart).rounded(.down).toInt()
let randomValue = Int.rand(0, maxIntegerPart)
let result = min + Self(randomValue)/maxFloatPart
return Self((result*maxFloatPart).toInt())/maxFloatPart
}
}

Utilisation

print("\(Int.rand(1, 20))")
print("\(Float.rand(5.231233, 44.5, precision: 3))")
print("\(Double.rand(5.231233, 44.5, precision: 4))")
print("\(CGFloat.rand(5.231233, 44.5, precision: 6))")

Totalité De L'Échantillon

import Foundation
import CoreGraphics
func run() {
let min = 2.38945
let max = 2.39865
for _ in 0...100 {
let precision = Int.rand(0, 5)
print("Precision: \(precision)")
floatSample(min: Float(min), max: Float(max), precision: precision)
floatSample(min: Double(min), max: Double(max), precision: precision)
floatSample(min: CGFloat(min), max: CGFloat(max), precision: precision)
intSample(min: Int(1), max: Int(10000))
print("")
}
}
private func printResult<T: Comparable>(min: T, max: T, random: T) {
let result = "\(T.self) rand[\(min), \(max)] = \(random)"
print(result)
}
func floatSample<T: BinaryFloatingPoint>(min: T, max: T, precision: Int) {
printResult(min: min, max: max, random: T.rand(min, max, precision: precision))
}
func intSample<T: BinaryInteger>(min: T, max: T) {
printResult(min: min, max: max, random: T.rand(min, max))
}

Résultats