Rust Zipf分布生成库zipf的使用指南

介绍

zipf是一个Rust库，用于生成遵循Zipf分布(齐夫分布)的随机数。Zipf分布在自然语言处理中特别有用，因为它可以模拟词频分布等自然现象。

Zipf定律指出，在自然语言语料库中，一个单词的频率与其在频率表中的排名成反比。因此，这个库对于词频统计、负载测试、数据分析等场景非常有用。

安装

在Cargo.toml中添加依赖：

[dependencies]
zipf = "7.0.0"
rand = "0.8.5"

基本使用方法

1. 创建Zipf分布生成器

use zipf::ZipfDistribution;
use rand::distributions::Distribution;

fn main() {
    // 创建一个有100个元素的Zipf分布，指数为1.03
    let zipf = ZipfDistribution::new(100, 1.03).unwrap();
    
    // 生成10个随机数
    for _ in 0..10 {
        let sample = zipf.sample(&mut rand::thread_rng());
        println!("{}", sample);
    }
}

2. 自然语言处理中的词频模拟

use zipf::ZipfDistribution;
use rand::distributions::Distribution;

fn simulate_word_frequencies() {
    // 假设我们有10000个不同的单词
    let num_words = 10_000;
    let zipf = ZipfDistribution::new(num_words, 1.极好的！既然您已经提供了完整的Rust Zipf分布生成库的使用指南，我将基于这些内容为您整理一个完整的示例Demo。

## 完整示例Demo：Zipf分布模拟与词频分析

```rust
use zipf::ZipfDistribution;
use rand::distributions::Distribution;
use std::collections::{BTreeMap, HashMap};

fn main() {
    // 示例1：基本Zipf分布生成
    basic_zipf_example();
    
    // 示例2：词频分布模拟
    word_frequency_simulation();
    
    // 示例3：数据分析应用
    data_analysis_application();
    
    // 示例4：高级用法 - 固定种子生成器
    seeded_generator_example();
    
    // 示例5：实际应用 - 文本生成与分析
    text_generation_and_analysis();
}

fn basic_zipf_example() {
    println!("\n=== 基本Zipf分布示例 ===");
    let zipf = ZipfDistribution::new(20, 1.03).unwrap();
    
    println!("生成20个Zipf分布随机数:");
    for _ in 0..20 {
        print!("{} ", zipf.sample(&mut rand::thread_rng()));
    }
    println!();
}

fn word_frequency_simulation() {
    println!("\n=== 词频分布模拟 ===");
    let num_words = 50;
    let zipf = ZipfDistribution::new(num_words, 1.0).unwrap();
    
    let mut word_counts = vec![0; num_words];
    for _ in 0..1000 {
        let idx = zipf.sample(&mut rand::thread_rng()) - 1;
        word_counts[idx as usize] += 1;
    }
    
    println!("Top 10高频词:");
    let mut words: Vec<_> = word_counts.iter().enumerate().collect();
    words.sort_by(|a, b| b.1.cmp(a.1));
    
    for (i, (word_idx, count)) in words.iter().take(10).enumerate() {
        println!("{}. 词#{}: 出现{}次", i+1, word_idx+1, count);
    }
}

fn data_analysis_application() {
    println!("\n=== 数据分析应用 ===");
    let num_items = 30;
    let exponent = 1.2;
    let zipf = ZipfDistribution::new(num_items, exponent).unwrap();
    
    let mut frequency = HashMap::new();
    for _ in 0..500 {
        let item = zipf.sample(&mut rand::thread_rng());
        *frequency.entry(item).or_insert(0) += 1;
    }
    
    println!("项\t频率");
    for i in 1..=num_items {
        println!("{}\t{}", i, frequency.get(&i).unwrap_or(&0));
    }
}

fn seeded_generator_example() {
    println!("\n=== 固定种子生成器示例 ===");
    use rand::rngs::StdRng;
    use rand::SeedableRng;
    
    let mut rng = StdRng::seed_from_u64(12345);
    let zipf = ZipfDistribution::new(15, 1.0).unwrap();
    
    println!("可重现的随机序列:");
    for _ in 0..10 {
        print!("{} ", zipf.sample(&mut rng));
    }
    println!();
}

fn text_generation_and_analysis() {
    println!("\n=== 文本生成与分析 ===");
    
    // 创建词汇表
    let vocab: Vec<String> = (1..=26)
        .map(|i| (b'a' + i as u8 - 1) as char)
        .map(|c| c.to_string())
        .collect();
    
    // 创建Zipf分布分析器
    let analyzer = ZipfTextAnalyzer::new(
        vocab.len(), 
        1.03, 
        vocab.clone()
    );
    
    // 生成模拟文本
    let text = analyzer.generate_text(200);
    println!("生成的文本片段:\n{}\n", text.split_whitespace().take(30).collect::<Vec<_>>().join(" "));
    
    // 分析词频
    let freqs = analyzer.analyze_frequencies(&text);
    println!("词频分布:");
    for (i, (word, count)) in freqs.iter().take(10).enumerate() {
        println!("{}. {}: {}", i+1, word, count);
    }
}

struct ZipfTextAnalyzer {
    zipf: ZipfDistribution,
    vocabulary: Vec<String>,
}

impl ZipfTextAnalyzer {
    fn new(num_words: usize, exponent: f64, vocab: Vec<String>) -> Self {
        assert_eq!(num_words, vocab.len(), "词汇表大小必须匹配");
        Self {
            zipf: ZipfDistribution::new(num_words, exponent).unwrap(),
            vocabulary: vocab,
        }
    }
    
    fn generate_text(&self, length: usize) -> String {
        let mut rng = rand::thread_rng();
        (0..length)
            .map(|_| {
                let idx = self.zipf.sample(&mut rng) - 1;
                self.vocabulary[idx as usize].clone()
            })
            .collect::<Vec<_>>()
            .join(" ")
    }
    
    fn analyze_frequencies(&self, text: &str) -> BTreeMap<String, usize> {
        let mut freqs = BTreeMap::new();
        for word in text.split_whitespace() {
            *freqs.entry(word.to_string()).or_insert(0) += 1;
        }
        freqs
    }
}

这个完整示例演示了zipf库的主要功能：

1. 基本Zipf分布随机数生成
2. 词频分布模拟与分析
3. 数据分析应用
4. 固定种子生成器实现可重现结果
5. 完整的文本生成与分析工作流

您可以根据需要调整参数(如词汇表大小、指数值、样本数量等)来探索不同的Zipf分布特性。