RandomKit
v5.2.3
RandomKit ist ein Swift -Framework, das die zufällige Datenerzeugung einfach und einfach macht.
| Zweig | Status |
|---|---|
master |
RandomKit ist möglicherweise auch mit FreeBSD, Android und Windows (unter Cygwin) kompatibel, wurde jedoch nicht auf diese Plattformen getestet.
Der Swift -Paketmanager ist für Swift ein dezentraler Abhängigkeitsmanager.
Fügen Sie das Projekt Ihrem Package.swift hinzu.
import PackageDescription
let package = Package (
name : " MyAwesomeProject " ,
dependencies : [
. Package ( url : " https://github.com/nvzqz/RandomKit.git " ,
majorVersion : 5 )
]
)Importieren Sie das RandomKit -Modul.
import RandomKitCocoapods ist ein zentraler Abhängigkeitsmanager für Objective-C und Swift. Gehen Sie hierher, um mehr zu erfahren.
Fügen Sie das Projekt Ihrer Podfile hinzu.
use_frameworks!
pod 'RandomKit' , '~> 5.2.3'Wenn Sie sich am Blutungskante befinden möchten, ersetzen Sie die letzte Linie durch::
pod 'RandomKit' , :git => 'https://github.com/nvzqz/RandomKit.git' Führen Sie pod install aus und öffnen Sie die .xcworkspace -Datei, um Xcode zu starten.
Importieren Sie das RandomKit -Framework.
import RandomKitKarthago ist ein dezentraler Abhängigkeitsmanager für Objective-C und Swift.
Fügen Sie das Projekt zu Ihrem Cartfile hinzu.
github "nvzqz/RandomKit"
Führen Sie carthage update aus und befolgen Sie die zusätzlichen Schritte, um Ihrem Projekt zufällige Kennzeichen hinzuzufügen.
Importieren Sie das RandomKit -Framework.
import RandomKit Verschiedene Komponenten von RandomKit können leicht durch das Laufen benchmark.sh bewertet werden.
./benchmark.sh [FLAGS] [PROTOCOLS] Verwenden Sie das Flag --help -Flag, um Informationen darüber zu erhalten, wie Sie es verwenden.
HINWEIS: Die Standardzahl beträgt 10000000, was viel ist, wenn die Flagge --array verwendet wird. Dies kann geändert werden, indem ein Argument in --count oder -c übergeben wird.
Probieren Sie es selbst aus! Laden Sie das Repo herunter und öffnen Sie "randomkit.playground".
Das RandomGenerator -Protokoll definiert grundlegende Methoden zur Erzeugung von primitiven Werten und zur Randomisierung eines Puffers.
Alle bereitgestellten Typen, die dem RandomGenerator entsprechen, haben einen statischen default , der als inout -Argument an Generierungsfunktionen übergeben werden kann.
let value = Int . random ( using : & Xoroshiro . default ) ARC4Random
arc4random -Funktionsfamilie von Funktionen nicht mit der Foundation auf Linux und anderen Plattformen exportiert werden, werden sie zur Laufzeit dynamisch geladen. DeviceRandom
MersenneTwister
Xoroshiro
Xorshift
XorshiftStar
ChaCha
SeedableRandomGenerator ist für Typen, die mit einigen zugeordneten Seed ausgesät werden können.
Das RandomBytesGenerator -Protokoll ist für Typen bestimmt, die sich auf die Erzeugung eines bestimmten Typs spezialisiert haben, der eine Reihe von Bytes ausfüllt. Zum Beispiel ist MersenneTwister auf die Erzeugung UInt64 spezialisiert, während Xorshift UInt32 -Werte erzeugt.
Bei Programmen mit Single-Thread-Programmen ist es sicher, eine globale Generatorinstanz wie Xoroshiro.default als Quelle der Zufälligkeit zu verwenden.
Für Multi-Thread-Programme sollten die Thread-lokalen Instanzen verwendet werden. Dies ermöglicht verschiedene Threads, ihre eigenen zufälligen Generatoren ohne gemeinsam genutzte mutable Zustand zu verwenden.
Im folgenden Beispiel ist randomGenerator für jeden Thread einzigartig.
let randomBytes = Xoroshiro . withThreadLocal { randomGenerator in
return [ UInt8 ] ( randomCount : 1000 , using : & randomGenerator )
}Thread-lokale Generatoren werden nach dem Ausgang des Threads behandelt, sodass sich keine Sorgen um die Reinigung machen müssen.
Es wird empfohlen, withThreadLocal(_:) oder den threadLocal -Zeiger in jeder einzelnen Zeit zu erhalten, die er benötigt. Das Abrufen der Thread-lokalen Instanz verursacht vermeidbare Overhead.
// Bad
let value = Int . random ( using : & Xoroshiro . threadLocal . pointee )
array . shuffle ( using : & Xoroshiro . threadLocal . pointee )
// Good
let threadLocal = Xoroshiro . threadLocal
let value = Int . random ( using : & threadLocal . pointee )
array . shuffle ( using : & threadLocal . pointee )
// Better
Xoroshiro . withThreadLocal { randomGenerator in
let value = Int . random ( using : & randomGenerator )
array . shuffle ( using : & randomGenerator )
}Als Verknüpfung können Sie sogar eine Funktion direkt als Parameter anwenden.
let value = Xoroshiro . withThreadLocal ( Int . random ) Vor V4.4.0 konnte die Gewindesicherheit erreicht werden, indem eine neue gesetzte Instanz eines bestimmten RandomGenerator -Typs instanziiert wird. Das Problem dabei ist, dass jedes Mal unnötige Aussaat auftritt. Damit wird der Generator einmal ausgesät und kann dann zu späteren Stellen wiederverwendet werden.
Verknüpfungen zur Wiederversammlung eines Generators sind ebenfalls verfügbar:
Xoroshiro . withThreadLocalReseeding {
...
}Welches ist viel besser als zu schreiben:
ReseedingRandomGenerator . withThreadLocal ( createdWith : { Xoroshiro . reseeding } ) {
...
}RandomKit ist sehr protokollorientiert, was ihm die Fähigkeit verleiht, sehr flexibel und modular zu sein.
Ein Protokoll für Typen, das mit einem RandomGenerator zufällige Werte erzeugen kann.
Ein Protokoll für Typen, mit denen optionale Zufallswerte innerhalb eines Bereichs unter Verwendung eines RandomGenerator erzeugt werden können.
Int . random ( in : 0 ..< 0 , using : & randomGenerator ) // nil Ein Protokoll für Typen, das mit einem RandomGenerator zufällige Werte innerhalb eines geschlossenen Bereichs erzeugen kann.
Int . random ( in : - 100 ... 100 , using : & randomGenerator ) // -79Ein Protokoll für Typen, die zufällige Werte von einem Basiswert zu einem anderen Wert erzeugen können, nicht inklusiv.
Der Basiswert für Ganzzahlen beträgt 0. Dies bedeutet, dass das Aufrufen random(to:using:) Ein negativer Wert ergibt einen zufälligen negativen Wert oder Null, während ein positiver Wert einen zufälligen positiven Wert oder Null ergibt.
Wenn value == randomBase , wird value für random(to:using:) .
Int . random ( to : 2 , using : & randomGenerator ) // Either 0 or 1
Int . random ( to : 0 , using : & randomGenerator ) // Always 0
Int . random ( to : 32 , using : & randomGenerator ) // 15
Int . random ( to : - 5 , using : & randomGenerator ) // -3Ein Protokoll für Typen, das zufällige Werte aus einem Basiswert über einen anderen Wert inklusive erzeugen kann.
Die gleichen Regeln bezüglich des Basiswerts von RandomToValue gelten für RandomThroughValue .
Ein Protokoll für Typen, deren Instanzen zufällige Elemente abrufen können.
[ " Bob " , " Cindy " , " May " , " Charles " , " Javier " ] . random ( using : & randomGenerator ) // "Charles"
" Hello " . characters . random ( using : & randomGenerator ) // "e" Einige Foundation -Typen wie NSArray entsprechen diesem Protokoll.
Ein Protokoll für Typen, deren Instanzen zufällige Elemente innerhalb eines Range<Index> erhalten können.
[ 20 , 37 , 42 ] . random ( in : 1 ..< 3 , using : & randomGenerator ) // Either 37 or 42Ein Protokoll für Typen, deren Elemente gemischt werden können.
// Array
[ 1 , 2 , 3 , 4 , 5 ] . shuffled ( using : & randomGenerator ) // [3, 4, 1, 5, 2]
// Dictionary
[ " a " : 1 , " b " : 2 , " c " : 3 ] . shuffled ( using : & randomGenerator ) // ["a": 3, "b": 1, "c": 2] Das veränderliche Gegenstück von shuffled(using:) ist shuffle(using:) .
Für eine bessere Ausweichung Array -Mischung in Betracht ziehen, mit shuffle(using:) zu mischen.
Ähnlich wie Shuffleable , außer dass kein Element jemals in seiner anfänglichen Position liegt.
Alle nativen Ganzzahltypen von Swift entsprechen den Random- .
Die random(using:) Die Funktion erstellt eine Ganzzahl eines jeden Werts. Infolgedessen können negative Werte für signierte Ganzzahlen entstehen.
Int . random ( using : & randomGenerator ) // An Int within Int.min and Int.max
Int . random ( in : 10 ... 20 , using : & randomGenerator ) // An Int within 10 and 20 Um eine positive signierte Ganzzahl zu erstellen, verwenden Sie random(to:using:) oder random(through:using:) .
Int . random ( to : 1000 , using : & randomGenerator ) // 731
Int . random ( through : 10 , using : & randomGenerator ) // 4Signierte Ganzzahlen können aus jeder Reichweite erstellt werden, ohne Überlaufgefahr.
Int . random ( in : ( . min + 1000 ) ... ( . max - 200 ) , using : & randomGenerator ) // 5698527899712144154 Generieren Sie standardmäßig einen zufälligen schwebenden Punktwert aus einem Bereich oder 0.0...1.0 .
Double . random ( using : & randomGenerator ) // 0.9813615573117475
Double . random ( in : - 10 ... 10 , using : & randomGenerator ) // -4.03042337718197
Float . random ( in : - 10 ... 10 , using : & randomGenerator ) // 5.167088
Float80 . random ( in : - 10 ... 10 , using : & randomGenerator ) // -3.63204542399198874 Alle FloatingPoint -Typen können auch RandomInClosedRange außerhalb des Boxs entsprechen.
Bool.random(using:) hat eine 50/50 Chance, true zu sein.
Wenn Sie eine unterschiedliche Wahrscheinlichkeit benötigen, gibt es auch random(withWeight:using:) , was eine weight hat, true zu sein.
String , Character und UnicodeScalar erzeugen standardmäßig Werte in " "..."~" .
String . random ( ofLength : 10 , using : & randomGenerator ) // "}+[=Ng>$w1"
String . random ( ofLength : 10 , in : " A " ... " z " , using : & randomGenerator ) // "poUtXJIbv["
Character . random ( using : & randomGenerator ) // "#"
Character . random ( in : " A " ... " z " , using : & randomGenerator ) // "s" Für Typen, die mit Init Random entsprechen, kann ein Array von Zufallswerten generiert werden init(randomCount:using:) .
Ähnliche Initialisierer existieren für alle anderen Random- .
let randoms = Array < Int > ( randomCount : 100 , using : & randomGenerator ) // [8845477344689834233, -957454203475087100, ...] Für Typen, die an UnsafeRandom entsprechen, ist eine schnellere Alternative init(unsafeRandomCount:using:) . Dieser Initialisierer füllt den Puffer direkt anstatt random(using:) .
let unsafeRandoms = Array < Int > ( unsafeRandomCount : 100 , using : & randomGenerator ) // [759709806207883991, 4618491969012429761, ...] Ein Maßstab für die Erzeugung von 1000 zufälligen Int -Arrays von 10000 Zählungen:
| Generator | Zeit (in Sekunden) |
|---|---|
Xoroshiro | 0,0271 |
Xorshift | 0,0568 |
XorshiftStar | 0,0319 |
ChaCha | 0,2027 |
MersenneTwister | 0,0432 |
ARC4Random | 0,2416 |
DeviceRandom | 5.3348 |
Hinweis: Die Ergebnisse können aufgrund verschiedener Faktoren variieren.
Der gleiche Benchmark kann mit:
./benchmark.sh --all-generators --array 10000 --count 1000 Ein Date kann zwischen zwei Date oder TimeInterval -Werten generiert werden.
Die Standard random(using:) Funktion gibt ein Date innerhalb Date.distantFuture Date.distantPast zurück.
Date . random ( using : & randomGenerator ) // "Aug 28, 2006, 3:38 AM"
Date . random ( in : Date . distantPast ... Date ( ) , using : & randomGenerator ) // "Feb 7, 472, 5:40 AM" Der Decimal entspricht verschiedenen Random- .
Die random(using:) Funktion gibt standardmäßig eine Decimal zwischen 0 und 1 zurück.
Decimal . random ( using : & randomGenerator ) // 0.87490000409886706715888973957833129437
Decimal . random ( in : 0.0 ... 10.0 , using : & randomGenerator ) // 6.5464639772070720738747790627821299859 Eine Zufallszahl kann innerhalb einer Ganzzahl oder einem Doppelbereich oder 0...100 standardmäßig generiert werden.
NSNumber . random ( using : & randomGenerator ) // 79
NSNumber . random ( in : - 50 ... 100 , using : & randomGenerator ) // -27
NSNumber . random ( in : 100 ... 200 , using : & randomGenerator ) // 149.6156950363926Eine zufällige Farbe kann mit oder ohne zufällige Alpha erzeugt werden.
NSColor . random ( using : & randomGenerator ) // r 0.694 g 0.506 b 0.309 a 1.0
NSColor . random ( alpha : true , using : & randomGenerator ) // r 0.859 g 0.57 b 0.409 a 0.047
UIColor . random ( using : & randomGenerator ) // r 0.488 g 0.805 b 0.679 a 1.0
UIColor . random ( alpha : true , using : & randomGenerator ) // r 0.444 g 0.121 b 0.602 a 0.085 Da CGFloat FloatingPoint entspricht, entspricht es RandomInClosedRange wie Double und Float .
CGFloat . random ( using : & randomGenerator ) // 0.699803650379181
CGFloat . random ( in : 0 ... 100 , using : & randomGenerator ) // 43.27969591675319Ein zufälliger Punkt kann aus den Bereichen für x und y erzeugt werden.
CGPoint . random ( using : & randomGenerator ) // {x 70.093 y 95.721}
CGPoint . random ( xRange : 0 ... 200 , yRange : 0 ... 10 , using : & randomGenerator ) // {x 73.795 y 0.991}Eine zufällige Größe kann aus Reichweiten für Breite und Höhe erzeugt werden.
CGSize . random ( using : & randomGenerator ) // {w 3.744 h 35.932}
CGSize . random ( widthRange : 0 ... 50 , heightRange : 0 ... 400 , using : & randomGenerator ) // {w 38.271 h 239.636}Ein zufälliges Rechteck kann aus den Bereichen für X, Y, Breite und Höhe erzeugt werden.
CGRect . random ( using : & randomGenerator ) // {x 3.872 y 46.15 w 8.852 h 20.201}
CGRect . random ( xRange : 0 ... 50 ,
yRange : 0 ... 100 ,
widthRange : 0 ... 25 ,
heightRange : 0 ... 10 ,
using : & randomGenerator ) // {x 13.212 y 79.147 w 20.656 h 5.663}Ein zufälliger Vektor kann aus Reichweiten für DX und DY erzeugt werden.
CGVector . random ( using : & randomGenerator ) // {dx 13.992 dy 89.376}
CGVector . random ( dxRange : 0 ... 50 , dyRange : 0 ... 10 , using : & randomGenerator ) // {dx 35.224 dy 13.463}RandomKit -Erweiterungen für die Bigint -Bibliothek von Károly sind in RandomkitBigint erhältlich.
Randomkit und seine Vermögenswerte werden im Rahmen der MIT -Lizenz veröffentlicht. Vermögenswerte können im assets -Zweig gefunden werden.
Teile dieses Projekts verwenden Code von Matt Gallagher und in Verbindung mit der MIT -Lizenz sind mit dem hier zu findenen.
