Rust区间处理库rust-lapper的使用：高效处理基因组和数值区间的查询与操作

以下是内容中提供的示例代码：

use rust_lapper::{Interval, Lapper};

type Iv = Interval<usize, u32>;
fn main() {
    // 创建一些测试数据
    let data: Vec<Iv> = vec![
        Iv {
            start: 70,
            stop: 120,
            val: 0,
        }, // max_len = 50
        Iv {
            start: 10,
            stop: 15,
            val: 0,
        },
        Iv {
            start: 10,
            stop: 15,
            val: 0,
        }, // 完全重叠
        Iv {
            start: 12,
            stop: 15,
            val: 0,
        }, // 内部重叠
        Iv {
            start: 14,
            stop: 16,
            val: 0,
        }, // 末端重叠
        Iv {
            start: 40,
            stop: 45,
            val: 0,
        },
        Iv {
            start: 50,
            stop: 55,
            val: 0,
        },
        Iv {
            start: 60,
            stop: 65,
            val: 0,
        },
        Iv {
            start: 68,
            stop: 71,
            val: 0,
        }, // 起始重叠
        Iv {
            start: 70,
            stop: 75,
            val: 0,
        },
    ];

    // 创建lapper结构
    let mut lapper = Lapper::new(data);

    // 使用基于迭代器的find方法提取所有与6..7重叠的区间
    // 如果查询是按start排序的，使用seek方法可以保留光标以获得大幅速度提升
    assert_eq!(
        lapper.find(11, 15).collect::<Vec<&Iv>>(),
        vec![
            &Iv {
                start: 10,
                stop: 15,
                val: 0
            },
            &Iv {
                start: 10,
                stop: 15,
                val: 0
            }, // 完全重叠
            &Iv {
                start: 12,
                stop: 15,
                val: 0
            }, // 内部重叠
            &Iv {
                start: 14,
                stop: 16,
            val: 0
            }, // 末端重叠
        ]
    );

    // 合并lapper中的重叠区域，以简化和加速仅依赖'any'的查询
    lapper.merge_overlaps();
    assert_eq!(
        lapper.find(11, 15).collect::<Vec<&Iv>>(),
        vec![&Iv {
            start: 10,
            stop: 16,
            val: 0
        },]
    );

    // 获取lapper树覆盖的位置数量
    assert_eq!(lapper.cov(), 73);

    // 获取两个不同lapper树的并集和交集
    let data = vec![
        Iv {
            start: 5,
            stop: 15,
            val: 0,
        },
        Iv {
            start: 48,
            stop: 80,
            val: 0,
        },
    ];
    let (union, intersect) = lapper.union_and_intersect(&Lapper::new(data));
    assert_eq!(union, 88);
    assert_eq!(intersect, 27);

    // 获取lapper覆盖的每个位置的深度
    for interval in lapper.depth().filter(|x| x.val > 2) {
        println!(
            "Depth at {} - {}: {}",
            interval.start, interval.stop, interval.val
        );
    }
}

完整示例代码

以下是一个完整的rust-lapper使用示例，展示了如何高效处理数值区间查询：

use rust_lapper::{Interval, Lapper};

// 定义区间类型
type Iv = Interval<usize, u32>;

fn main() {
    // 1. 创建测试数据 - 基因组区间示例
    let genome_regions = vec![
        Iv { start: 1000, stop: 1500, val: 1 },  // 基因1
        Iv { start: 3000, stop: 3500, val: 2 },  // 基因2
        Iv { start: 5000, stop: 5500, val: 3 },  // 基因3
        Iv { start: 1500, stop: 2000, val: 4 },  // 非编码区
        Iv { start: 1200, stop: 1800, val: 5 },  // 重叠区域
    ];

    // 2. 构建Lapper结构
    let mut lapper = Lapper::new(genome_regions);
    
    // 3. 基本查询示例
    println!("=== 基本查询 ===");
    let query_region = Iv { start: 1300, stop: 1700, val: 0 };
    let overlaps = lapper.find(query_region.start, query_region.stop)
        .collect::<Vec<&Iv>>();
    
    println!("查询区域 {}..{} 重叠的区间:", query_region.start, query_region.stop);
    for iv in overlaps {
        println!("- {}..{} (val: {})", iv.start, iv.stop, iv.val);
    }

    // 4. 合并重叠区间
    println!("\n=== 合并重叠区间 ===");
    lapper.merge_overlaps();
    println!("合并后覆盖的基因组位置数: {}", lapper.cov());

    // 5. 深度分析
    println!("\n=== 深度分析 ===");
    println!("深度大于1的区域:");
    for interval in lapper.depth().filter(|x| x.val > 1) {
        println!("{}..{}: 深度 {}", interval.start, interval.stop, interval.val);
    }

    // 6. 与另一个区间集合比较
    println!("\n=== 区间集合比较 ===");
    let other_regions = vec![
        Iv { start: 1000, stop: 1800, val: 0 },
        Iv { start: 4000, stop: 4500, val: 0 },
    ];
    let other_lapper = Lapper::new(other_regions);
    
    let (union, intersect) = lapper.union_and_intersect(&other_lapper);
    println!("并集覆盖: {} bp", union);
    println!("交集覆盖: {} bp", intersect);

    // 7. 快速计数
    println!("\n=== 快速计数 ===");
    let count = lapper.count(1000, 2000);
    println!("1000..2000区间内的重叠计数: {}", count);
}

关键特性说明

1. 高性能区间查询：rust-lapper在典型数据集上比其他区间重叠方法快4-10倍
2. BITS计数算法：count方法对数据类型不可知，速度极快
3. 多种操作支持：
   • 查找重叠区间 (find)
   • 合并重叠区间 (merge_overlaps)
   • 计算覆盖度 (cov)
   • 区间深度分析 (depth)
   • 区间集合运算 (union_and_intersect)

安装使用

在Cargo.toml中添加依赖：

[dependencies]
rust-lapper = "1.2.0"

如果需要serde支持：

[dependencies]
rust-lapper = { version = "1.2.0", features = ["with_serde"] }

适用场景

rust-lapper特别适合处理：

• 基因组坐标区间分析
• 数值区间查询与操作
• 需要高性能区间处理的应用场景

需要注意的是，rust-lapper不适合处理包含超长区间(覆盖大多数其他区间)的数据。对于这种情况，可以考虑使用COItres或IITree等替代方案。