Swift 介于0和1之间的快速随机浮点

在Swift中，我试图得到一个介于0和1之间的随机浮点值，但我似乎无法使类型转换工作

func randomCGFloat() -> CGFloat {
    return CGFloat(arc4random()) / UINT32_MAX
}

我得到一个“CGFloat”不能转换为“UInt8”错误

---

运行Xcode 6。

尝试将除数初始化为浮点，即la:

CGFloat(Float(arc4random()) / Float(UINT32_MAX))

---

jmduke的建议似乎适用于游乐场，但功能有一点变化：

func randomCGFloat() -> Float {
    return Float(arc4random()) /  Float(UInt32.max)
}

根据swift文件和drewag所述，类型转换的原因必须明确，文件中的示例如下：

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi equals 3.14159, and is inferred to be of type Double

---

这是Int、Double、Float、CGFloat的随机数的扩展

Swift 3&4&5语法

import Foundation
import CoreGraphics

// MARK: Int Extension

public extension Int {

    /// Returns a random Int point number between 0 and Int.max.
    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
    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
    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.
    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
    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.
    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
    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.
    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.
    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
    static func random(min: CGFloat, max: CGFloat) -> CGFloat {
        return CGFloat.random * (max - min) + min
    }
}

使用：

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)

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

---

下面是执行此操作的

IntervalType

类型的扩展：

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
    }
}

使用此扩展，您可以使用interval语法生成一个interval，然后在该interval中获取一个随机值：

(0.0...1.0).random()

添加

如果您希望对

Int

s执行相同的操作，则可以在

CollectionType

协议上使用以下扩展：

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
    }
}

Int

s不要使用

IntervalType

。他们使用

范围

。在

CollectionType

类型上执行此操作的好处是，它会自动转入

字典

和

数组

类型

示例：

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

---

在Swift中，框架可以很好地生成随机数数据：

更新Swift 3：

extension ClosedRange where Bound : FloatingPoint {
    public func random() -> Bound {
        let range = self.upperBound - self.lowerBound
        let randomValue = (Bound(arc4random_uniform(UINT32_MAX)) / Bound(UINT32_MAX)) * range + self.lowerBound
        return randomValue
    }
}

现在你可以说像

（-1.0…1.0）.random（）

编辑我想今天（Swift 4）我会这样写：

extension ClosedRange where Bound : FloatingPoint {
    public func random() -> Bound {
        let max = UInt32.max
        return
            Bound(arc4random_uniform(max)) /
            Bound(max) *
            (upperBound - lowerBound) +
            lowerBound
    }
}

注意Swift 4.2引入了本机随机数生成，所有这些都变得毫无意义

根据YannickSteph的回答

要使其适用于任何浮点类型，如

Double

、

Float

、

CGFloat

等，可以对

BinaryFloatingPoint

类型进行扩展：

extension BinaryFloatingPoint {

    /// Returns a random floating point number between 0.0 and 1.0, inclusive.
    public static var random: Self {
        return Self(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: Self, max: Self) -> Self {
        return Self.random * (max - min) + min
    }
}

细节 代码：9.2，Swift 4

解决方案 用法 全样本 <代码>导入基础 导入核心图形 func run（）{ 设最小值=2.38945 设max=2.39865 对于0…100中的uu{ 设精度=Int.rand（0,5） 打印（“精度：\（精度）”） 浮动采样（最小：浮动（最小）、最大：浮动（最大）、精度：精度） 浮动采样（最小值：双精度（最小值）、最大值：双精度（最大值）、精度：精度） floatSample（最小：CGFloat（最小），最大：CGFloat（最大），精度：精度） intSample（最小值：Int（1），最大值：Int（10000）） 打印（“”） } } 私有函数打印结果（最小值：T，最大值：T，随机值：T）{ let result=“\（T.self）rand[\（min），\（max）]=\（随机）” 打印（结果） } func floatSample（最小值：T，最大值：T，精度：Int）{ 打印结果（最小值：最小值，最大值：最大值，随机值：T.rand（最小值，最大值，精度：精度）） } func intSample（最小值：T，最大值：T）{ 打印结果（最小值：最小值，最大值：最大值，随机值：T.rand（最小值，最大值）） } 结果

---

万一你需要[加倍]。介于0和1之间。就这些。

swift 4.2:

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)

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

---

let randomFloat=Float.random（in:0..Swift 5

let randomFloat = CGFloat.random(in: 0...1)

谢谢，我试过用CGFloat来转换分母，但是没有效果。但是看起来好像先转换成一个float，然后再转换成CGFloat是有效的。不需要通过
float
–只需
CGFloat（arc4random（））/CGFloat（UInt32.max）
@Joe\u Schmoe如果不使用Float/CGFloat，则除法是一个小整数除以一个大整数，并且总是返回0。但是在swift 4.2中，只需使用：Float.random（in:0..@DaRk-uuu-D0G，我试图理解数学。为什么要用0xFFFFFFFF除以random（）对于Float和Double？@ethanick add Update for Swift 2 look；）“无法调用非函数类型'CGFloat'的值”尝试使用CGFloat.random时出现错误（最小值：0.1，最大值：10.1）Swift 4不需要更新。@YannickSteph对于Swift 5和Xcode 10.2，行
返回Float（arc4random（））/0xFFFFFF
现在给出一个警告：
'4294967295'不能准确地表示为'Float'；它变成了'4294967296'
。知道如何解决这个警告吗？我想除以
Float（UInt32.max）
相反。我们如何使这一点也适用于Ints，这不是最初的问题，但如果我们要进行扩展，这可能是下一步IntervalType@Joe_Schmoe：我已更新了我的答案，并提供了有关使用
.random（）的详细信息
在
Int
s、
Dictionary
s和
Array
s上，我非常喜欢这个解决方案，但我正在更新，以包含更好的通用实践，在Swift 3中被破坏。这在为
通用iOS设备编译时不起作用。
0xffffffff不适合在Int内。请改为尝试CGFloat（UInt32.max）相关：
drand48()

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

let randomFloat = CGFloat.random(in: 0...1)