Go库中随机数生成的最佳实践与策略

package monte

import (
    "math/rand"
)

const (
    DEFAULT_STEPS = 100000 // 默认积分步数
)

// Naive 是一个简单的Monte Carlo积分器
type Naive struct {
    rand  *rand.Rand // 独立的随机数生成器实例
    steps int        // 积分步数
}

// NewNaive 创建一个新的Naive积分器实例。
// 它接受一个rand.Source接口作为参数，允许调用者提供自定义的随机数源。
func NewNaive(source rand.Source) *Naive {
    return &Naive{rand.New(source), DEFAULT_STEPS}
}

// SetSteps 设置积分步数
func (m *Naive) SetSteps(steps int) {
    m.steps = steps
}

// Integrate1D 对一维函数在给定区间[a, b]上进行积分
func (m *Naive) Integrate1D(fn func(float64) float64, a, b float64) float64 {
    var sum float64
    for i := 0; i < m.steps; i++ {
        // 在区间[a, b]内生成随机数
        x := a + (b-a)*m.rand.Float64()
        sum += fn(x)
    }
    // 返回积分结果
    return (b - a) * sum / float64(m.steps)
}

package main

import (
    "fmt"
    "math"
    "math/rand"
    "time" // 引入time包用于播种

    "monte" // 引入monte库
)

func main() {
    // 使用固定种子创建随机数源，方便测试和重现
    // m := monte.NewNaive(rand.NewSource(200)) 

    // 使用当前时间作为种子，提供更真实的随机性
    m := monte.NewNaive(rand.NewSource(time.Now().UTC().UnixNano()))

    // 计算圆周率 (通过积分单位圆的四分之一面积)
    pi := 4 * m.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1 - t*t)
    }, 0, 1)
    fmt.Printf("估算的圆周率: %f\n", pi)

    // 改变步数以提高精度
    m.SetSteps(1000000)
    pi = 4 * m.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1 - t*t)
    }, 0, 1)
    fmt.Printf("更高精度估算的圆周率: %f\n", pi)
}

package keygen

import (
    "crypto/rand"
    "encoding/base32"
    "fmt"
)

// GenKey 生成一个加密安全的随机密钥字符串。
// 密钥长度为20字节，并使用Base32编码。
func GenKey() (string, error) {
    b := make([]byte, 20) // 创建一个20字节的切片
    // 从crypto/rand读取随机字节
    if _, err := rand.Read(b); err != nil {
        return "", fmt.Errorf("无法生成随机字节: %w", err)
    }
    // 使用自定义的Base32编码字符集
    enc := base32.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZ346789")
    return enc.EncodeToString(b), nil
}

package shuffle

import (
    "math/rand"
    "time"
)

// r 是包私有的随机数生成器实例
var r *rand.Rand

// init 函数在包加载时执行，用于初始化私有随机数生成器
func init() {
    // 使用当前时间作为种子，创建并初始化一个独立的rand.Rand实例
    r = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
}

// ShuffleStrings 使用Fisher-Yates算法对字符串切片进行原地洗牌
func ShuffleStrings(arr []string) {
    last := len(arr) - 1
    for i := range arr {
        // 生成一个0到last之间的随机索引j
        // 注意：这里的j的范围应是[i, last]，以确保所有元素都有机会被交换
        // 修正后的Fisher-Yates算法通常是从后往前或从前往后，但随机选择未处理的元素
        // 为了简单起见和与原始问题答案保持一致，这里使用0到last
        // 更标准的Fisher-Yates可以这样：
        // j := r.Intn(last + 1 - i) + i // 随机选择 i 到 last 之间的索引
        // arr[i], arr[j] = arr[j], arr[i]
        // 或者从后往前：
        // for i := len(arr) - 1; i > 0; i-- {
        //    j := r.Intn(i + 1)
        //    arr[i], arr[j] = arr[j], arr[i]
        // }

        // 原始示例中的简化版本，可能在某些情况下不如标准算法均匀
        j := r.Intn(last + 1) // 生成0到last之间的随机索引
        arr[i], arr[j] = arr[j], arr[i]
    }
}

package main

import (
    "fmt"
    "shuffle" // 引入shuffle库
)

func main() {
    arr := []string{"a", "set", "of", "words"}
    fmt.Printf("原始词语: %v\n", arr)

    fmt.Println("\n进行10次洗牌操作:")
    for i := 0; i < 10; i++ {
        shuffle.ShuffleStrings(arr)
        fmt.Printf("洗牌后词语 %d: %v\n", i+1, arr)
    }
}