Пакет rand
Обзор
Пакет rand реализует генераторы псевдослучайных чисел, подходящие для таких задач, как моделирование, но его не следует использовать в задачах, требующих безопасности.
Случайные числа генерируются источником Source, обычно обёрнутым в Rand. Оба типа следует использовать только одной горутине одновременно: совместное использование несколькими горутинами требует какой-либо синхронизации.
Функции верхнего уровня, такие как Float64 и Int, безопасны для одновременного использования несколькими горутинами.
Источник ChaCha8 предназначен для общего использования и устойчив к предсказанию. Источник PCG работает быстрее, но не подходит для задач, связанных с безопасностью.
Выходные данные этого пакета могут быть легко предсказуемы независимо от способа задания начального значения. Для генерации случайных чисел, подходящих для задач, требующих безопасности, см. пакет crypto/rand.
Пример
Код:
answers := []string{
"It is certain",
"It is decidedly so",
"Without a doubt",
"Yes definitely",
"You may rely on it",
"As I see it yes",
"Most likely",
"Outlook good",
"Yes",
"Signs point to yes",
"Reply hazy try again",
"Ask again later",
"Better not tell you now",
"Cannot predict now",
"Concentrate and ask again",
"Don't count on it",
"My reply is no",
"My sources say no",
"Outlook not so good",
"Very doubtful",
}
fmt.Println("Magic 8-Ball says:", answers[rand.IntN(len(answers))])
Пример (Rand)
В этом примере показано использование каждого из методов типа *Rand. Глобальные функции используются так же, но без получателя.
Код:
// Create and seed the generator.
// Typically a non-fixed seed should be used, such as Uint64(), Uint64().
// Using a fixed seed will produce the same output on every run.
r := rand.New(rand.NewPCG(1, 2))
// The tabwriter here helps us generate aligned output.
w := tabwriter.NewWriter(os.Stdout, 1, 1, 1, ' ', 0)
defer w.Flush()
show := func(name string, v1, v2, v3 any) {
fmt.Fprintf(w, "%s\t%v\t%v\t%v\n", name, v1, v2, v3)
}
// Float32 and Float64 values are in [0, 1).
show("Float32", r.Float32(), r.Float32(), r.Float32())
show("Float64", r.Float64(), r.Float64(), r.Float64())
// ExpFloat64 values have an average of 1 but decay exponentially.
show("ExpFloat64", r.ExpFloat64(), r.ExpFloat64(), r.ExpFloat64())
// NormFloat64 values have an average of 0 and a standard deviation of 1.
show("NormFloat64", r.NormFloat64(), r.NormFloat64(), r.NormFloat64())
// Int32, Int64, and Uint32 generate values of the given width.
// The Int method (not shown) is like either Int32 or Int64
// depending on the size of 'int'.
show("Int32", r.Int32(), r.Int32(), r.Int32())
show("Int64", r.Int64(), r.Int64(), r.Int64())
show("Uint32", r.Uint32(), r.Uint32(), r.Uint32())
// IntN, Int32N, and Int64N limit their output to be < n.
// They do so more carefully than using r.Int()%n.
show("IntN(10)", r.IntN(10), r.IntN(10), r.IntN(10))
show("Int32N(10)", r.Int32N(10), r.Int32N(10), r.Int32N(10))
show("Int64N(10)", r.Int64N(10), r.Int64N(10), r.Int64N(10))
// Perm generates a random permutation of the numbers [0, n).
show("Perm", r.Perm(5), r.Perm(5), r.Perm(5))
Вывод:
Float32 0.95955694 0.8076733 0.8135684 Float64 0.4297927436037299 0.797802349388613 0.3883664855410056 ExpFloat64 0.43463410545541104 0.5513632046504593 0.7426404617374481 NormFloat64 -0.9303318111676635 -0.04750789419852852 0.22248301107582735 Int32 2020777787 260808523 851126509 Int64 5231057920893523323 4257872588489500903 158397175702351138 Uint32 314478343 1418758728 208955345 IntN(10) 6 2 0 Int32N(10) 3 7 7 Int64N(10) 8 9 4 Perm [0 3 1 4 2] [4 1 2 0 3] [4 3 2 0 1]
Индекс
Файлы пакета
chacha8.go exp.go normal.go pcg.go rand.go zipf.go
func ExpFloat64 1.22
func ExpFloat64() float64
ExpFloat64 возвращает значение типа float64, распределённое экспоненциально в диапазоне (0, +math.MaxFloat64], с экспоненциальным распределением, параметр интенсивности (lambda) которого равен 1, а математическое ожидание равно 1/lambda (1). Чтобы получить распределение с другим параметром интенсивности, вызывающий код может скорректировать результат следующим образом:
sample = ExpFloat64() / desiredRateParameter
func Float32 1.22
func Float32() float32
Float32 возвращает в виде float32 псевдослучайное число из полуинтервала [0.0,1.0), полученное от источника по умолчанию.
func Float64 1.22
func Float64() float64
Float64 возвращает в виде float64 псевдослучайное число из полуинтервала [0.0,1.0), полученное от источника по умолчанию.
func Int 1.22
func Int() int
Int возвращает неотрицательное псевдослучайное значение типа int, полученное от источника по умолчанию.
func Int32 1.22
func Int32() int32
Int32 возвращает неотрицательное псевдослучайное 31-битное целое число в виде int32, полученное от источника по умолчанию.
func Int32N 1.22
func Int32N(n int32) int32
Int32N возвращает в виде int32 псевдослучайное число из полуинтервала [0,n), полученное от источника по умолчанию. Вызывает панику, если n <= 0.
func Int64 1.22
func Int64() int64
Int64 возвращает неотрицательное псевдослучайное 63-битное целое число в виде int64, полученное от источника по умолчанию.
func Int64N 1.22
func Int64N(n int64) int64
Int64N возвращает в виде int64 псевдослучайное число из полуинтервала [0,n), полученное от источника по умолчанию. Вызывает панику, если n <= 0.
func IntN 1.22
func IntN(n int) int
IntN возвращает в виде int псевдослучайное число из полуинтервала [0,n), полученное от источника по умолчанию. Вызывает панику, если n <= 0.
Пример
Код:
fmt.Println(rand.IntN(100)) fmt.Println(rand.IntN(100)) fmt.Println(rand.IntN(100))
func N 1.22
func N[Int intType](n Int) Int
N возвращает псевдослучайное число из полуинтервала [0,n), полученное от источника по умолчанию. Параметр типа Int может быть любым целочисленным типом. Вызывает панику, если n <= 0.
Пример
Код:
// Print an int64 in the half-open interval [0, 100). fmt.Println(rand.N(int64(100))) // Sleep for a random duration between 0 and 100 milliseconds. time.Sleep(rand.N(100 * time.Millisecond))
func NormFloat64 1.22
func NormFloat64() float64
NormFloat64 возвращает значение типа float64, распределённое нормально в диапазоне [-math.MaxFloat64, +math.MaxFloat64], со стандартным нормальным распределением (среднее = 0, стандартное отклонение = 1), полученное от источника по умолчанию. Чтобы получить другое нормальное распределение, вызывающий код может скорректировать результат следующим образом:
sample = NormFloat64() * desiredStdDev + desiredMean
func Perm 1.22
func Perm(n int) []int
Perm возвращает в виде среза из n значений int псевдослучайную перестановку целых чисел из полуинтервала [0,n), полученную от источника по умолчанию.
Пример
Код:
for _, value := range rand.Perm(3) {
fmt.Println(value)
}
Вывод:
1 2 0
func Shuffle 1.22
func Shuffle(n int, swap func(i, j int))
Shuffle псевдослучайным образом меняет порядок элементов, используя источник по умолчанию. n — количество элементов. Shuffle вызывает панику, если n < 0. swap меняет местами элементы с индексами i и j.
Пример
Код:
words := strings.Fields("ink runs from the corners of my mouth")
rand.Shuffle(len(words), func(i, j int) {
words[i], words[j] = words[j], words[i]
})
fmt.Println(words)
Пример (SlicesInUnison)
Код:
numbers := []byte("12345")
letters := []byte("ABCDE")
// Shuffle numbers, swapping corresponding entries in letters at the same time.
rand.Shuffle(len(numbers), func(i, j int) {
numbers[i], numbers[j] = numbers[j], numbers[i]
letters[i], letters[j] = letters[j], letters[i]
})
for i := range numbers {
fmt.Printf("%c: %c\n", letters[i], numbers[i])
}
func Uint 1.23
func Uint() uint
Uint возвращает псевдослучайное значение типа uint, полученное от источника по умолчанию.
func Uint32 1.22
func Uint32() uint32
Uint32 возвращает псевдослучайное 32-битное значение в виде uint32, полученное от источника по умолчанию.
func Uint32N 1.22
func Uint32N(n uint32) uint32
Uint32N возвращает в виде uint32 псевдослучайное число из полуинтервала [0,n), полученное от источника по умолчанию. Вызывает панику, если n == 0.
func Uint64 1.22
func Uint64() uint64
Uint64 возвращает псевдослучайное 64-битное значение в виде uint64, полученное от источника по умолчанию.
func Uint64N 1.22
func Uint64N(n uint64) uint64
Uint64N возвращает в виде uint64 псевдослучайное число из полуинтервала [0,n), полученное от источника по умолчанию. Вызывает панику, если n == 0.
func UintN 1.22
func UintN(n uint) uint
UintN возвращает в виде uint псевдослучайное число из полуинтервала [0,n), полученное от источника по умолчанию. Вызывает панику, если n == 0.
type ChaCha8 1.22
ChaCha8 — это криптографически стойкий генератор случайных чисел на основе ChaCha8.
type ChaCha8 struct {
// contains filtered or unexported fields
}
func NewChaCha8 1.22
func NewChaCha8(seed [32]byte) *ChaCha8
NewChaCha8 возвращает новый ChaCha8, инициализированный указанным начальным значением.
func (*ChaCha8) AppendBinary 1.24
func (c *ChaCha8) AppendBinary(b []byte) ([]byte, error)
AppendBinary реализует интерфейс encoding.BinaryAppender.
func (*ChaCha8) MarshalBinary 1.22
func (c *ChaCha8) MarshalBinary() ([]byte, error)
MarshalBinary реализует интерфейс encoding.BinaryMarshaler.
func (*ChaCha8) Read 1.23
func (c *ChaCha8) Read(p []byte) (n int, err error)
Read считывает в p ровно len(p) байт. Метод всегда возвращает len(p) и nil в качестве ошибки.
Если вызовы Read и Uint64 чередуются, порядок возвращаемых ими битов не определён, а Read может вернуть биты, сгенерированные до последнего вызова Uint64.
func (*ChaCha8) Seed 1.22
func (c *ChaCha8) Seed(seed [32]byte)
Seed сбрасывает ChaCha8, чтобы он работал так же, как NewChaCha8(seed).
func (*ChaCha8) Uint64 1.22
func (c *ChaCha8) Uint64() uint64
Uint64 возвращает равномерно распределённое случайное значение типа uint64.
func (*ChaCha8) UnmarshalBinary 1.22
func (c *ChaCha8) UnmarshalBinary(data []byte) error
UnmarshalBinary реализует интерфейс encoding.BinaryUnmarshaler.
type PCG 1.22
PCG — это генератор PCG с внутренним состоянием размером 128 бит. Нулевое значение PCG эквивалентно NewPCG(0, 0).
type PCG struct {
// contains filtered or unexported fields
}
func NewPCG 1.22
func NewPCG(seed1, seed2 uint64) *PCG
NewPCG возвращает новый PCG, инициализированный указанными значениями.
func (*PCG) AppendBinary 1.24
func (p *PCG) AppendBinary(b []byte) ([]byte, error)
AppendBinary реализует интерфейс encoding.BinaryAppender.
func (*PCG) MarshalBinary 1.22
func (p *PCG) MarshalBinary() ([]byte, error)
MarshalBinary реализует интерфейс encoding.BinaryMarshaler.
func (*PCG) Seed 1.22
func (p *PCG) Seed(seed1, seed2 uint64)
Seed сбрасывает PCG, чтобы он работал так же, как NewPCG(seed1, seed2).
func (*PCG) Uint64 1.22
func (p *PCG) Uint64() uint64
Uint64 возвращает равномерно распределённое случайное значение типа uint64.
func (*PCG) UnmarshalBinary 1.22
func (p *PCG) UnmarshalBinary(data []byte) error
UnmarshalBinary реализует интерфейс encoding.BinaryUnmarshaler.
type Rand 1.22
Rand — это источник случайных чисел.
type Rand struct {
// contains filtered or unexported fields
}
func New 1.22
func New(src Source) *Rand
New возвращает новый Rand, который использует случайные значения из src для генерации других случайных значений.
func (*Rand) ExpFloat64 1.22
func (r *Rand) ExpFloat64() float64
ExpFloat64 возвращает значение типа float64, распределённое экспоненциально в диапазоне (0, +math.MaxFloat64], с экспоненциальным распределением, параметр интенсивности (lambda) которого равен 1, а математическое ожидание равно 1/lambda (1). Чтобы получить распределение с другим параметром интенсивности, вызывающий код может скорректировать результат следующим образом:
sample = ExpFloat64() / desiredRateParameter
func (*Rand) Float32 1.22
func (r *Rand) Float32() float32
Float32 возвращает в виде float32 псевдослучайное число из полуинтервала [0.0,1.0).
func (*Rand) Float64 1.22
func (r *Rand) Float64() float64
Float64 возвращает в виде float64 псевдослучайное число из полуинтервала [0.0,1.0).
func (*Rand) Int 1.22
func (r *Rand) Int() int
Int возвращает неотрицательное псевдослучайное значение типа int.
func (*Rand) Int32 1.22
func (r *Rand) Int32() int32
Int32 возвращает неотрицательное псевдослучайное 31-битное целое число в виде int32.
func (*Rand) Int32N 1.22
func (r *Rand) Int32N(n int32) int32
Int32N возвращает в виде int32 неотрицательное псевдослучайное число из полуинтервала [0,n). Вызывает панику, если n <= 0.
func (*Rand) Int64 1.22
func (r *Rand) Int64() int64
Int64 возвращает неотрицательное псевдослучайное 63-битное целое число в виде int64.
func (*Rand) Int64N 1.22
func (r *Rand) Int64N(n int64) int64
Int64N возвращает в виде int64 неотрицательное псевдослучайное число из полуинтервала [0,n). Вызывает панику, если n <= 0.
func (*Rand) IntN 1.22
func (r *Rand) IntN(n int) int
IntN возвращает в виде int неотрицательное псевдослучайное число из полуинтервала [0,n). Вызывает панику, если n <= 0.
func (*Rand) N
func (r *Rand) N[Int intType](n Int) Int
N возвращает псевдослучайное число из полуинтервала [0,n). Параметр типа Int может быть любым целочисленным типом. Вызывает панику, если n <= 0.
func (*Rand) NormFloat64 1.22
func (r *Rand) NormFloat64() float64
NormFloat64 возвращает значение типа float64, распределённое нормально в диапазоне от -math.MaxFloat64 до +math.MaxFloat64 включительно, со стандартным нормальным распределением (среднее = 0, стандартное отклонение = 1). Чтобы получить другое нормальное распределение, вызывающий код может скорректировать результат следующим образом:
sample = NormFloat64() * desiredStdDev + desiredMean
func (*Rand) Perm 1.22
func (r *Rand) Perm(n int) []int
Perm возвращает в виде среза из n значений int псевдослучайную перестановку целых чисел из полуинтервала [0,n).
func (*Rand) Shuffle 1.22
func (r *Rand) Shuffle(n int, swap func(i, j int))
Shuffle псевдослучайным образом меняет порядок элементов. n — количество элементов. Shuffle вызывает панику, если n < 0. swap меняет местами элементы с индексами i и j.
func (*Rand) Uint 1.23
func (r *Rand) Uint() uint
Uint возвращает псевдослучайное значение типа uint.
func (*Rand) Uint32 1.22
func (r *Rand) Uint32() uint32
Uint32 возвращает псевдослучайное 32-битное значение в виде uint32.
func (*Rand) Uint32N 1.22
func (r *Rand) Uint32N(n uint32) uint32
Uint32N возвращает в виде uint32 неотрицательное псевдослучайное число из полуинтервала [0,n). Вызывает панику, если n == 0.
func (*Rand) Uint64 1.22
func (r *Rand) Uint64() uint64
Uint64 возвращает псевдослучайное 64-битное значение в виде uint64.
func (*Rand) Uint64N 1.22
func (r *Rand) Uint64N(n uint64) uint64
Uint64N возвращает в виде uint64 неотрицательное псевдослучайное число из полуинтервала [0,n). Вызывает панику, если n == 0.
func (*Rand) UintN 1.22
func (r *Rand) UintN(n uint) uint
UintN возвращает в виде uint неотрицательное псевдослучайное число из полуинтервала [0,n). Вызывает панику, если n == 0.
type Source 1.22
Source — это источник равномерно распределённых псевдослучайных значений uint64 в диапазоне [0, 1<<64).
Source небезопасен для одновременного использования несколькими горутинами.
type Source interface {
Uint64() uint64
} type Zipf 1.22
Zipf генерирует случайные величины, распределённые по закону Ципфа.
type Zipf struct {
// contains filtered or unexported fields
}
func NewZipf 1.22
func NewZipf(r *Rand, s float64, v float64, imax uint64) *Zipf
NewZipf возвращает генератор случайных величин, распределённых по закону Ципфа. Генератор создаёт значения k ∈ [0, imax], для которых P(k) пропорционально (v + k) ** (-s). Требования: s > 1 и v >= 1.
func (*Zipf) Uint64 1.22
func (z *Zipf) Uint64() uint64
Uint64 возвращает значение, выбранное из распределения Ципфа, описанного объектом Zipf.
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/math/rand/v2/
