如何用Rust实现符合R语言逻辑的findInterval函数？

需求说明 #

函数find_interval(x, v)需实现以下逻辑：

• 遍历向量x的每个元素，与有序向量v的值比较
• 若x元素小于v[0]，返回Null（对应Rust中的None）
• 找到最大的索引i，使得x元素 >= v[i]，返回该索引；若元素大于所有v的值，返回v.len()-1

示例：
输入：

let x = vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18];
let v = vec![5, 10, 15];

预期输出：[Null, Null, Null, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2]

原代码问题分析 #

1. 返回类型错误：原函数返回Vec<u32>，无法表示Null，需改用Vec<Option<usize>>
2. 循环逻辑颠倒：原代码嵌套循环遍历v再遍历x，正确逻辑应为遍历每个x元素，为其匹配对应的v索引
3. 变量作用域混乱：内层循环的i与外层变量冲突，导致逻辑错误
4. 结果长度不符：原代码生成的结果向量长度远大于输入x的长度

修正后的find_interval函数 #

pub fn find_interval(x: Vec<u32>, v: Vec<u32>) -> Vec<Option<usize>> {
    // 断言v是非递减序列，符合逻辑前置要求
    debug_assert!(v.windows(2).all(|w| w[0] <= w[1]), "v必须是非递减序列");
    
    let mut result = Vec::with_capacity(x.len());
    
    for &num in &x {
        if num < v[0] {
            result.push(None);
            continue;
        }
        
        // 找到最大的索引i，满足v[i] <= num
        let mut idx = 0;
        while idx + 1 < v.len() && v[idx + 1] <= num {
            idx += 1;
        }
        result.push(Some(idx));
    }
    
    result
}

fn main() {
    let x = vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18];
    let v = vec![5, 10, 15];

    let result = find_interval(x, v);

    // 转换为示例要求的输出格式
    let output_str: Vec<String> = result.iter().map(|opt| match opt {
        None => "Null".to_string(),
        Some(&i) => i.to_string(),
    }).collect();
    println!("[{}]", output_str.join(", "));
}

代码说明 #

• 使用Option<usize>类型区分Null（None）和有效索引（Some(index)），完全匹配需求逻辑
• 遍历每个x元素，先判断是否小于v的首个元素，是则添加None
• 通过循环找到最大符合条件的v索引，确保逻辑正确性
• 添加debug断言验证v的非递减性，避免非法输入导致错误
• main函数将结果转换为示例要求的字符串格式输出，与预期一致

关联函数volatility_default_spread_f的修正 #

原函数存在类型不匹配、作用域错误、NaN判断错误等问题，修正后如下：

// 为f64类型实现find_interval
pub fn find_interval_f64(x: Vec<f64>, v: Vec<f64>) -> Vec<Option<usize>> {
    debug_assert!(v.windows(2).all(|w| w[0] <= w[1]), "v必须是非递减序列");
    
    let mut result = Vec::with_capacity(x.len());
    
    for &num in &x {
        if num < v[0] {
            result.push(None);
            continue;
        }
        
        let mut idx = 0;
        while idx + 1 < v.len() && v[idx + 1] <= num {
            idx += 1;
        }
        result.push(Some(idx));
    }
    
    result
}

pub fn volatility_default_spread_f(x: Vec<f64>) -> Vec<f64> {
    let spreads = vec![0.0099, 0.0165, 0.02068, 0.031625, 0.066125, 0.083375, 0.100625];
    let lcoverage = vec![0.0, 0.25, 0.4, 0.65, 0.75, 0.9, 1.0];
    
    // 遍历x的每个元素，单独处理
    x.into_iter().map(|val| {
        if val.is_nan() {
            0.0188
        } else {
            // 获取当前元素对应的索引
            let opt_idx = find_interval_f64(vec![val], lcoverage.clone()).into_iter().next().unwrap();
            match opt_idx {
                // 小于第一个阈值时取第一个spread值，可根据需求调整
                None => spreads[0],
                Some(idx) => spreads[idx.min(spreads.len() - 1)],
            }
        }
    }).collect()
}

修正说明 #

• 新增find_interval_f64函数，适配f64类型的输入需求
• 改用迭代器map处理每个x元素，符合Rust函数式编程风格
• 修复NaN判断逻辑，现在正确检查每个元素是否为NaN
• 处理索引越界问题，确保不会访问spreads的非法索引
• 修正变量作用域错误，保证返回值正确

内容的提问来源于stack exchange，提问作者Carlos Arias