RandomKit
v5.2.3
Randomkit é uma estrutura rápida que torna a geração de dados aleatória simples e fácil.
| Filial | Status |
|---|---|
master |
O RandomKit também é compatível com FreeBSD, Android e Windows (sob Cygwin), mas não foi testado para essas plataformas.
O Swift Package Manager é um gerente de dependência descentralizado da Swift.
Adicione o projeto ao seu Package.swift .
import PackageDescription
let package = Package (
name : " MyAwesomeProject " ,
dependencies : [
. Package ( url : " https://github.com/nvzqz/RandomKit.git " ,
majorVersion : 5 )
]
)Importar o módulo Randomkit.
import RandomKitO Cocoapods é um gerente de dependência centralizado para o Objective-C e Swift. Vá aqui para saber mais.
Adicione o projeto ao seu podfile.
use_frameworks!
pod 'RandomKit' , '~> 5.2.3'Se você quiser estar na borda do sangramento, substitua a última linha com:
pod 'RandomKit' , :git => 'https://github.com/nvzqz/RandomKit.git' Execute pod install e abra o arquivo .xcworkspace para iniciar o Xcode.
Importar a estrutura Randomkit.
import RandomKitCartago é um gerente de dependência descentralizado para o Objective-C e Swift.
Adicione o projeto ao seu arquivo Cart.
github "nvzqz/RandomKit"
Execute carthage update e siga as etapas adicionais para adicionar randomkit ao seu projeto.
Importar a estrutura Randomkit.
import RandomKit Vários componentes do RandomKit podem ser facilmente comparados com a realização de benchmark.sh .
./benchmark.sh [FLAGS] [PROTOCOLS] Use o sinalizador --help para obter informações sobre como usá -lo.
Nota: A contagem padrão é 10000000, o que é muito se estiver usando o sinalizador --array . Isso pode ser transformado passando um argumento para --count ou -c .
Experimente por si mesmo! Faça o download do repo e abra 'Randomkit.Playground'.
O protocolo RandomGenerator define métodos básicos para gerar valores primitivos e randomizar um buffer.
Todos os tipos fornecidos em conformidade com RandomGenerator têm um valor default estático que pode ser passado como um argumento inout para as funções de geração.
let value = Int . random ( using : & Xoroshiro . default ) ARC4Random
arc4random não são exportados com a Foundation on Linux e outras plataformas, elas são carregadas dinamicamente no tempo de execução. DeviceRandom
MersenneTwister
Xoroshiro
Xorshift
XorshiftStar
ChaCha
SeedableRandomGenerator é para tipos que podem ser semeados com algum tipo Seed associado.
O protocolo RandomBytesGenerator é para tipos especializados em gerar um tipo específico que preenche vários bytes. Por exemplo, MersenneTwister é especializado em gerar UInt64 enquanto Xorshift gera valores UInt32 .
Para programas de thread único, é seguro usar uma instância global do gerador, como Xoroshiro.default como fonte de aleatoriedade.
Para programas com vários threads, as instâncias locais devem ser usadas. Isso permite que diferentes threads usem seus próprios geradores aleatórios separados sem um estado mutável compartilhado.
No exemplo a seguir, randomGenerator é exclusivo para cada thread.
let randomBytes = Xoroshiro . withThreadLocal { randomGenerator in
return [ UInt8 ] ( randomCount : 1000 , using : & randomGenerator )
}Os geradores locais de threads são desalocados na saída do thread, portanto, não há necessidade de se preocupar com a limpeza.
É recomendável não ligar para withThreadLocal(_:) ou obtenha o ponteiro threadLocal a cada tempo individual necessário. A recuperação da instância local do thread incorre em sobrecarga evitável.
// 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 )
}Como atalho, você pode até aplicar uma função diretamente como um parâmetro.
let value = Xoroshiro . withThreadLocal ( Int . random ) Antes da v4.4.0, a segurança do encadeamento poderia ser alcançada instanciando uma nova instância semeada de um determinado tipo de RandomGenerator . O problema é que a semeadura desnecessária ocorre a cada vez. Com isso, o gerador é semeado uma vez e pode ser reutilizado em pontos posteriores.
Também estão disponíveis atalhos para a versão repercutora de um gerador:
Xoroshiro . withThreadLocalReseeding {
...
}O que é muito melhor do que escrever:
ReseedingRandomGenerator . withThreadLocal ( createdWith : { Xoroshiro . reseeding } ) {
...
}O RandomKit é muito orientado para o protocolo, o que lhe dá a capacidade de ser muito flexível e modular.
Um protocolo para tipos que podem gerar valores aleatórios usando um RandomGenerator .
Um protocolo para tipos que podem gerar valores aleatórios opcionais dentro de um intervalo usando um RandomGenerator .
Int . random ( in : 0 ..< 0 , using : & randomGenerator ) // nil Um protocolo para tipos que podem gerar valores aleatórios dentro de uma faixa fechada usando um RandomGenerator .
Int . random ( in : - 100 ... 100 , using : & randomGenerator ) // -79Um protocolo para tipos que podem gerar valores aleatórios de um valor base para outro valor, não inclusivo.
O valor base para os números inteiros é 0. Isso significa que chamar random(to:using:) em um valor negativo produzirá um valor negativo aleatório ou zero, enquanto um valor positivo produzirá um valor positivo ou zero aleatório.
Se value == randomBase , value será retornado para 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 ) // -3Um protocolo para tipos que podem gerar valores aleatórios de um valor base através de outro valor, inclusive.
As mesmas regras referentes ao valor base da RandomToValue se aplicam ao RandomThroughValue .
Um protocolo para tipos cujas instâncias podem ter elementos aleatórios recuperados.
[ " Bob " , " Cindy " , " May " , " Charles " , " Javier " ] . random ( using : & randomGenerator ) // "Charles"
" Hello " . characters . random ( using : & randomGenerator ) // "e" Alguns tipos de fundação, como NSArray estão em conformidade com este protocolo.
Um protocolo para tipos cujas instâncias podem ter elementos aleatórios recuperados em um Range<Index> .
[ 20 , 37 , 42 ] . random ( in : 1 ..< 3 , using : & randomGenerator ) // Either 37 or 42Um protocolo para tipos cujos elementos podem ser embaralhados.
// 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] A contraparte mutável de shuffled(using:) é shuffle(using:) .
Para um melhor desempenho de embaralhamento Array , considere embaralhando no local com shuffle(using:) .
Semelhante ao Shuffleable , exceto que nenhum elemento está em sua posição inicial.
Todos os tipos inteiros nativos de Swift estão em conformidade com os protocolos Random- .
A random(using:) Função cria um número inteiro de qualquer valor. Como resultado, valores negativos podem resultar em números inteiros assinados.
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 Para criar um número inteiro assinado positivo, use random(to:using:) ou random(through:using:) .
Int . random ( to : 1000 , using : & randomGenerator ) // 731
Int . random ( through : 10 , using : & randomGenerator ) // 4Os números inteiros assinados podem ser criados a partir de qualquer intervalo, sem perigo de transbordamento.
Int . random ( in : ( . min + 1000 ) ... ( . max - 200 ) , using : & randomGenerator ) // 5698527899712144154 Gere um valor de ponto flutuante aleatório dentro de um intervalo ou 0.0...1.0 por padrão.
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 Todos os tipos de FloatingPoint também podem estar em conformidade com RandomInClosedRange pronta para uso.
Bool.random(using:) tem uma chance de 50/50 de ser true .
Se você precisar de uma probabilidade diferente, também há aleatório (com weight random(withWeight:using:) , que tem 1 chance de ser true .
String , Character e UnicodeScalar geram valores dentro de " "..."~" por padrão.
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" Uma matriz de valores aleatórios pode ser gerada para tipos em conformidade com Random com init(randomCount:using:) .
Existem inicializadores semelhantes para todos os outros protocolos Random- .
let randoms = Array < Int > ( randomCount : 100 , using : & randomGenerator ) // [8845477344689834233, -957454203475087100, ...] Para os tipos que estão em conformidade com UnsafeRandom , uma alternativa mais rápida é init(unsafeRandomCount:using:) . Este inicializador preenche o buffer diretamente em vez de usar random(using:) .
let unsafeRandoms = Array < Int > ( unsafeRandomCount : 100 , using : & randomGenerator ) // [759709806207883991, 4618491969012429761, ...] Uma referência de geração de 1000 matrizes aleatórias Int de 10000 contagem:
| Gerador | Tempo (em segundos) |
|---|---|
Xoroshiro | 0,0271 |
Xorshift | 0,0568 |
XorshiftStar | 0,0319 |
ChaCha | 0,2027 |
MersenneTwister | 0,0432 |
ARC4Random | 0,2416 |
DeviceRandom | 5.3348 |
Nota: Os resultados podem variar devido a vários fatores.
Este mesmo benchmark pode ser executado com:
./benchmark.sh --all-generators --array 10000 --count 1000 Uma Date aleatória pode ser gerada entre dois valores Date ou TimeInterval .
A random(using:) Função Retorna uma Date dentro Date.distantPast e Date.distantFuture .
Date . random ( using : & randomGenerator ) // "Aug 28, 2006, 3:38 AM"
Date . random ( in : Date . distantPast ... Date ( ) , using : & randomGenerator ) // "Feb 7, 472, 5:40 AM" O tipo Decimal está em conformidade com vários protocolos Random- .
A random(using:) Função retorna um Decimal entre 0 e 1 por padrão.
Decimal . random ( using : & randomGenerator ) // 0.87490000409886706715888973957833129437
Decimal . random ( in : 0.0 ... 10.0 , using : & randomGenerator ) // 6.5464639772070720738747790627821299859 Um número aleatório pode ser gerado a partir de um número inteiro ou duplo, ou 0...100 por padrão.
NSNumber . random ( using : & randomGenerator ) // 79
NSNumber . random ( in : - 50 ... 100 , using : & randomGenerator ) // -27
NSNumber . random ( in : 100 ... 200 , using : & randomGenerator ) // 149.6156950363926Uma cor aleatória pode ser gerada, com ou sem alfa aleatória.
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 Como CGFloat está em conformidade com FloatingPoint , ele está em conformidade com a RandomInClosedRange , exatamente como Double e Float .
CGFloat . random ( using : & randomGenerator ) // 0.699803650379181
CGFloat . random ( in : 0 ... 100 , using : & randomGenerator ) // 43.27969591675319Um ponto aleatório pode ser gerado a partir de intervalos para x e y.
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}Um tamanho aleatório pode ser gerado a partir de intervalos para largura e altura.
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}Um retângulo aleatório pode ser gerado a partir de intervalos para x, y, largura e altura.
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}Um vetor aleatório pode ser gerado a partir de intervalos para DX e DY.
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}As extensões randomkit para a biblioteca Bigint de Károly estão disponíveis no RandomKitbigint.
Randomkit e seus ativos são liberados sob a licença do MIT. Os ativos podem ser encontrados no ramo de assets .
As partes deste projeto utilizam o código escrito por Matt Gallagher e, em conjunto com a licença do MIT, são licenciados com o encontrado aqui.
