Question

我目前正在开展一个简单的项目，让自己熟悉Rust。我没有太多的系统编程经验，但我希望学习！

我试图创建一个Matrix结构，但我发现很难弄清楚应该如何存储数据。我觉得我应该能够使用数组。矩阵的大小必须在构造上定义，所以我希望我可以将数组存储在堆栈中。

现在我的代码看起来像这样：

FOR

Answer 1

最简单的方法是使用Vec。

struct Matrix {
    cols: i32,
    rows: i32,
    data: Vec<f32>
}

impl Matrix {
    fn new(cols: i32, rows: i32) -> Matrix {
        Matrix {
            cols: cols,
            rows: rows,
            data: vec![0.0; cols * rows]
        }
    }
}

如果您不想将数据存储在堆上，可以将Matrix变为动态大小的类型，但这很难做到并且不受支持。请参阅a Reddit thread on that topic。

如果您不想使用Vec但是可以将数据存储在堆上，则可以使用盒装切片（Box<[f32]>）。有关创建一种方法的信息，请参阅Vec::into_boxed_slice。

当然，如果你真的不想使用堆，你可以为不同大小的矩阵制作不同的Matrix类型。这就是箱子nalgebra的作用。

Answer 2

您也可以使用向量（Vec<Vec<T>>）的向量，而无需实现自己的Matrix或使用库。但这在索引方面比Adrian的方法明显慢。 nalgebra擅长矢量化计算，但在元素运算方面，它比由Vec<T>或Vec<Vec<T>>组成的简单矩阵的性能差。以下是一些基准测试：

test bench_vec               ... bench:  84,694,933 ns/iter (+/- 7,412,836)
test bench_vec_of_vec        ... bench:  87,083,636 ns/iter (+/- 1,171,842)
test bench_vec_unsafe        ... bench:  41,440,947 ns/iter (+/- 752,463)
test bench_vec_of_vec_unsafe ... bench:  44,532,595 ns/iter (+/- 629,209)
test bench_nalgebra          ... bench: 452,872,630 ns/iter (+/- 40,284,295)

#![feature(test)]

extern crate test;
use na::Matrix;
use na::{Dynamic, VecStorage};
use nalgebra as na;

type DMatrixi32 = Matrix<u8, Dynamic, Dynamic, VecStorage<u8, Dynamic, Dynamic>>;

use test::Bencher;

#[bench]
fn bench_vec_of_vec(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = vec![vec![0u8; n]; m];
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                matrix[i][j] = 1u8;
            }
        }
    });
}

#[bench]
fn bench_vec(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = vec![0u8; n * m];
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                matrix[i * n + j] = 1u8;
            }
        }
    });
}

#[bench]
fn bench_vec_of_vec_unsafe(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = vec![vec![0u8; n]; m];
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                unsafe {
                    *matrix.get_unchecked_mut(i).get_unchecked_mut(j) = 1u8;
                }
            }
        }
    });
}

#[bench]
fn bench_vec_unsafe(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = vec![0u8; n * m];
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                unsafe { *matrix.get_unchecked_mut(i * n + j) = 1u8 };
            }
        }
    });
}

#[bench]
fn bench_nalgebra(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = DMatrixi32::from_vec(m, n, vec![0u8; n * m]);
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                matrix[(i, j)] = 1u8;
            }
        }
    });
}

使用数组创建结构（矩阵）

2 个答案: