rand64
1.0.0
Le package rand64 fournit des générateurs de nombres pseudo-aléatoires produisant des nombres 64 bits non signés dans la plage [0, 2 64 ).
Les implémentations des générateurs de nombres pseudo-aléatoires suivants sont fournies dans leurs propres packages :
Ces générateurs implémentent rand.Source64, ils peuvent donc être utilisés comme source pour rand.Rand (à partir de Go 1.8).
Notez que certains algorithmes utilisent le package bits de Go 1.9.
La création d'un PRNG ressemble à ceci :
// create a source with the xoshiro256**
source := &xoshiro.Rng256SS{}
// use it as a source in rand.New
rng := rand.New(&source)
// Seed it from a single int64 (negative values are accepted)
rng.Seed(int64Seed)
Il s'agit d'une version à incrément fixe du générateur SplittableRandom de Java 8. Voir aussi la page sur les générateurs de nombres pseudo-aléatoires divisibles rapidement.
Implémentation Go basée sur une implémentation de référence C par Sebastiano Vigna.
Période 2 256 -1
Selon les auteurs de l'algorithme :
xoshiro256** (XOR/shift/rotate) est notre générateur polyvalent et solide comme le roc (mais pas un générateur cryptographiquement sécurisé). Il a une excellente vitesse (sub-ns), un espace d'état (256 bits) suffisamment grand pour toute application parallèle et il réussit tous les tests dont nous avons connaissance.
Si, toutefois, il faut générer uniquement des nombres à virgule flottante de 64 bits (en extrayant les 53 bits supérieurs), xoshiro256+ est un générateur légèrement (≈15 %) plus rapide avec des propriétés statistiques analogues. Pour un usage général, il faut considérer que ses bits les plus bas ont une faible complexité linéaire et échoueront aux tests de linéarité ; cependant, une faible complexité linéaire peut n'avoir pratiquement aucun impact dans la pratique, et n'a certainement aucun impact si vous générez des nombres à virgule flottante en utilisant les bits supérieurs (nous avons calculé une estimation précise de la complexité linéaire des bits les plus bas).
Période 2 128 -1
Selon les auteurs de l'algorithme :
xoroshiro128** (XOR/rotate/shift/rotate) et xoroshiro128+ ont la même vitesse que xoshiro256 et utilisent la moitié de l'espace ; les mêmes commentaires s’appliquent. Ils conviennent uniquement aux applications parallèles à petite échelle ; de plus, xoroshiro128+ présente une légère dépendance aux poids de Hamming qui génère un échec après 5 To de sortie dans notre test. Nous pensons que ce léger biais ne peut affecter aucune candidature.
Implémentation Go basée sur une implémentation de référence C par David Blackman et Sebastiano Vigna.
Pour plus d'informations, visitez les générateurs xoshiro / xoroshiro et la page PRNG shootout.
Période 2 128
Il s'agit d'un générateur congruentiel permuté tel que défini dans
PCG : une famille d'algorithmes simples, rapides et efficaces sur le plan statistique pour la génération de nombres aléatoires
Melissa E. O'Neill, Collège Harvey Mudd
https://www.cs.hmc.edu/tr/hmc-cs-2014-0905.pdf
Alors que PCG fait référence à toute une famille d'algorithmes (voir aussi http://pcg-random.org), le seul algorithme fourni est PCG XSL RR 128/64 LCG.
Implémentation Go basée sur l'implémentation de référence C par Melissa O'Neill et les contributeurs du projet PCG.
Période 2 19937 -1
Il s'agit d'une implémentation Go pure basée sur l'implémentation mt19937-64.c C de Makoto Matsumoto et Takuji Nishimura.
Plus d'informations sur l'algorithme Mersenne Twister et d'autres implémentations sont disponibles sur http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
Notez que cet algorithme est uniquement destiné aux applications nécessitant une interopérabilité avec d’autres applications utilisant ce même algorithme. Comme il est connu qu'il échoue à des tests statistiques triviaux et qu'il est le plus lent sur amd64, son utilisation à d'autres fins n'est pas recommandée.
Pas un véritable PRNG.
Le package IoRand est un simple wrapper pour lire des flux d'octets via io.Reader. Il peut être utilisé comme wrapper autour de crypto/rand pour créer un rand.Source64 pour le package math/rand :
package main
import (
"bufio"
crand "crypto/rand"
"encoding/binary"
"math/rand"
"github.com/db47h/rand64/v3/iorand"
)
// Wrap crypto/rand in an IoRand
func main () {
// first, wrap crypto/rand.Reader in a buffered bufio.Reader
bufferedReader := bufio . NewReader ( crand . Reader )
// Create the new IoRand Source
ior := iorand . New ( bufferedReader , binary . LittleEndian )
// use it as rand.Source64
rng := rand . New ( ior )
// get random numbers...
for i := 0 ; i < 4 ; i ++ {
_ = rng . Uint64 ()
}
}Ces benchmarks ont été terminés avec la version 1.12.5.
| Algorithme | AMD FX-6300 | Core i5 6200U | ARM Cortex-A7 à 900 MHz |
|---|---|---|---|
| xoshiro256** | 5,53 ns/opération | 106,0 ns/opération | |
| xoshiro256+ | 5,48 ns/opération | 86,1 ns/op | |
| xoroshiro128** | 5,16 ns/opération | 79,2 ns/op | |
| xoroshiro128+ | 5,15 ns/opération | 62,7 ns/op | |
| PCG XSL RR 128/64 LCG | 5,29 ns/op | 254,0 ns/opération | |
| splitmix64 | 4h30 ns/op | 77,5 ns/opération | |
| Mersenne Twister 19937 | 8,82 ns/opération | 136,0 ns/opération | |
| Allez maths/rand | 7.01 ns/op | 68,4 ns/opération |
Notez que les tests montrent des performances plus lentes par rapport aux versions précédentes. Cela est dû au fait que nous avons bien appelé Rng.Uint64 directement au lieu de passer par l'interface rand.Rand64. Afin de faire une comparaison équitable avec le rng de la bibliothèque standard Go, tous les benchmarks passent désormais par une interface rand.Source64.
Éloignez-vous du splitmix64 et du vénérable Mersenne-Twister 19937.
On sait très peu de choses sur le math/rand de Go (voir ici, ici) et il existe une proposition visant à le remplacer par un générateur PCG.
Les PCG, xoshiro256** et xoroshiro128** fournis sont réputés avoir réussi tous les tests connus ; selon leurs auteurs respectifs. Attention cependant aux mauvaises performances de cet algorithme PCG particulier sur les plates-formes 32 bits (affecte à la fois ARM et x86).
rand64 prend en charge les modules go. Les versions précédentes 1.x et 2.x ont été déplacées vers leurs branches respectives. Étant donné que les balises semver sans go.mod semblaient perturber les modules go, les balises de ces versions ont été réinitialisées.
Ce package est publié selon les termes de la licence ISC (voir le fichier LICENSE à la racine du référentiel). De plus, l'utilisation des algorithmes suivants est régie par des licences supplémentaires :
