Estoy tratando de generar un número aleatorio entre 0 y 1. Sigo leyendo sobre arc4random(), pero no hay información sobre cómo obtener un flotador de él. ¿Cómo hago esto?

Valor aleatorio en [0, 1[ (including 0, excluding 1):

double val = ((double)arc4random() / UINT32_MAX);

A bit more details here.

Actual range is [0, 0.999999999767169356]como límite superior es (doble) 0xFFFFFFFF / 0x100000000.

// Seed (only once)
srand48(time(0));

double x = drand48();

// Swift version
// Seed (only once)
srand48(Int(Date().timeIntervalSince1970))

let x = drand48()

Las funciones drand48() y erand48() devuelven valores de punto flotante no negativos, de doble precisión, distribuidos uniformemente en el intervalo [0.0 , 1.0].

Para Swift 4.2+ ver: https://stackoverflow.com/a/50733095/1033581

A continuación, se incluyen recomendaciones para lograr una uniformidad correcta y una precisión óptima para ObjC y Swift 4.1.

Precisión de 32 bits (óptima para Float)

Valor aleatorio uniforme en [0, 1] (incluyendo 0.0 y 1.0), hasta 32 bits de precisión:

Obj-C:

float val = (float)arc4random() / UINT32_MAX;

Rápido:

let val = Float(arc4random()) / Float(UInt32.max)

Es óptimo para:

• a Float (o Float32) que tiene una precisión significativa de 24 bits para su mantisa

Precisión de 48 bits (desaconsejada)

Es fácil lograr una precisión de 48 bits con drand48 (que utiliza arc4random_buf bajo el capó). Pero ten en cuenta que drand48 tiene defectos debido al requisito de semilla y también por ser subóptimo para aleatorizar los 52 bits de Double mantissa.

Valor aleatorio uniforme en [0, 1]precisión de 48 bits:

Rápido:

// seed (only needed once)
srand48(Int(Date.timeIntervalSinceReferenceDate))
// random Double value
let val = drand48()

Precisión de 64 bits (óptima para Double y Float80)

Valor aleatorio uniforme en [0, 1] (incluyendo 0.0 y 1.0), hasta 64 bits de precisión:

Rápidousando dos llamadas a arc4random:

let arc4random64 = UInt64(arc4random()) << 32 &+ UInt64(arc4random())
let val = Float80(arc4random64) / Float80(UInt64.max)

Rápidousando una llamada a arc4random_buf:

var arc4random64: UInt64 = 0
arc4random_buf(&arc4random64, MemoryLayout.size(ofValue: arc4random64))
let val = Float80(arc4random64) / Float80(UInt64.max)

Es óptimo para:

• a Double (o Float64) que tiene una precisión significativa de 52 bits para su mantisa
• a Float80 que tiene una precisión significativa de 64 bits para su mantisa

notas

Comparaciones con otros métodos

Las respuestas donde el rango excluye uno de los límites (0 o 1) probablemente sufran un sesgo de uniformidad y deben evitarse.

• utilizando arc4random()la mejor precisión es 1/0xFFFFFFFF (UINT32_MAX)
• utilizando arc4random_uniform()la mejor precisión es 1/0xFFFFFFFE (UINT32_MAX-1)
• utilizando rand() (secretamente usando arc4random), la mejor precisión es 1 / 0x7FFFFFFF (RAND_MAX)
• utilizando random() (secretamente usando arc4random), la mejor precisión es 1 / 0x7FFFFFFF (RAND_MAX)

Es matemáticamente imposible lograr una precisión superior a 32 bits con una sola llamada a arc4random, arc4random_uniform, rand o random. Por lo tanto, nuestras soluciones anteriores de 32 bits y 64 bits deberían ser las mejores que podamos lograr.

Esta función también funciona para rangos flotantes negativos:

float randomFloat(float Min, float Max){
    return ((arc4random()%RAND_MAX)/(RAND_MAX*1.0))*(Max-Min)+Min;
}

Rápido 4.2+

Swift 4.2 agrega soporte nativo para un valor aleatorio en un rango:

let x = Float.random(in: 0.0...1.0)
let y = Double.random(in: 0.0...1.0)
let z = Float80.random(in: 0.0...1.0)

Doc:

• random(in range: ClosedRange<Float>)
• random(in range: Range<Float>)
• random(in range: ClosedRange<Double>)
• random(in range: Range<Double>)
• random(in range: ClosedRange<Float80>)
• random(in range: Range<Float80>)

(float)rand() / RAND_MAX

La publicación anterior que decía “rand ()” solo era incorrecta. Esta es la forma correcta de usar rand().

Esto creará un número entre 0 -> 1

Documentos BSD:

La función rand() calcula una secuencia de enteros pseudoaleatorios en el
rango de 0 a RAND_MAX (como se define en el archivo de encabezado “stdlib.h”).

Esta es la extensión para el número aleatorio flotante Rápido 3.1

// 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()) / Float(UInt32.max))
    }

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