Rust ndarray：如何将切片转为&[T]和&mut [T]传递给函数

ndarray的as_slice()/as_mut_slice()仅对连续存储的数组有效，非连续切片（如带步长的视图、跨维度切片）调用这些方法会返回None。以下分场景给出解决办法：

一、处理连续Array3或连续切片 #

如果你的Array3是连续创建的（比如用Array3::from_shape_vec生成，未做非连续切片操作），直接调用as_slice()/as_mut_slice()即可：

use ndarray::Array3;

fn process_slice(data: &[f32]) {
    println!("Received slice length: {}", data.len());
}

fn process_mut_slice(data: &mut [f32]) {
    for val in data.iter_mut() {
        *val *= 2.0;
    }
}

fn main() {
    let mut arr = Array3::from_shape_vec((2, 2, 2), vec![1.0; 8]).unwrap();
    
    // 转不可变切片
    if let Some(slice) = arr.as_slice() {
        process_slice(slice);
    }
    
    // 转可变切片
    if let Some(slice) = arr.as_mut_slice() {
        process_mut_slice(slice);
    }
}

二、处理非连续Array3切片（视图） #

方案1：复制数据到连续临时数组 #

将非连续数据拷贝到新的连续数组，再转切片。适合数据量较小的场景：

use ndarray::{Array3, s};

fn process_slice(data: &[f32]) {
    println!("Received slice length: {}", data.len());
}

fn main() {
    let arr = Array3::from_shape_vec((2, 2, 2), vec![1.0; 8]).unwrap();
    // 取非连续切片（所有行的第一列）
    let non_continuous_view = arr.slice(s![.., 0, ..]);
    
    // 复制到临时连续数组
    let temp_arr = non_continuous_view.to_owned();
    process_slice(temp_arr.as_slice().unwrap());
}

方案2：按内存顺序获取切片（避免拷贝） #

使用as_slice_memory_order()方法，它会返回内存中实际存储顺序的切片，但注意这个顺序可能和视图的逻辑顺序不一致：

use ndarray::{Array3, s};

fn process_slice(data: &[f32]) {
    println!("Received slice length: {}", data.len());
}

fn main() {
    let arr = Array3::from_shape_vec((2, 2, 2), vec![1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0]).unwrap();
    let non_continuous_view = arr.slice(s![.., 0, ..]);
    
    // 按内存顺序取切片
    if let Some(slice) = non_continuous_view.as_slice_memory_order() {
        process_slice(slice);
        println!("Slice content (memory order): {:?}", slice);
    }
}

三、可变非连续切片的处理 #

方案1：复制到临时可变数组并写回 #

use ndarray::{Array3, s};

fn process_mut_slice(data: &mut [f32]) {
    for val in data.iter_mut() {
        *val += 1.0;
    }
}

fn main() {
    let mut arr = Array3::from_shape_vec((2, 2, 2), vec![1.0; 8]).unwrap();
    let mut non_continuous_view = arr.slice_mut(s![.., 0, ..]);
    
    // 复制到临时可变数组
    let mut temp_arr = non_continuous_view.to_owned();
    process_mut_slice(temp_arr.as_mut_slice().unwrap());
    // 将修改后的数据写回原视图
    non_continuous_view.assign(&temp_arr);
}

方案2：按内存顺序获取可变切片 #

use ndarray::{Array3, s};

fn process_mut_slice(data: &mut [f32]) {
    for val in data.iter_mut() {
        *val += 1.0;
    }
}

fn main() {
    let mut arr = Array3::from_shape_vec((2, 2, 2), vec![1.0; 8]).unwrap();
    let mut non_continuous_view = arr.slice_mut(s![.., 0, ..]);
    
    if let Some(slice) = non_continuous_view.as_mut_slice_memory_order() {
        process_mut_slice(slice);
    }
}

额外建议：直接传递视图类型 #

如果函数不需要严格的&[T]，更推荐让函数接受ArrayView3<T>或ArrayViewMut3<T>类型，这样可以直接传递ndarray视图，无需转换切片，同时保留维度信息：

use ndarray::{Array3, ArrayView3, ArrayViewMut3, s};

fn process_view(view: ArrayView3<f32>) {
    println!("View shape: {:?}", view.shape());
}

fn process_mut_view(view: ArrayViewMut3<f32>) {
    view.iter_mut().for_each(|val| *val *= 2.0);
}

fn main() {
    let mut arr = Array3::from_shape_vec((2, 2, 2), vec![1.0; 8]).unwrap();
    
    let view = arr.slice(s![.., .., 0]);
    process_view(view);
    
    let mut mut_view = arr.slice_mut(s![.., 0, ..]);
    process_mut_view(mut_view);
}

内容的提问来源于stack exchange，提问作者Sergio Cavaleiro Costa