linearalgebra 0.2.1

Test project to learn Rust and implement a small library for linear algebra
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#![feature(test)]

extern crate rand;
extern crate test;

use std::time::Instant;

use linearalgebra::matrix::Matrix;
use rand::Rng;
use test::Bencher;

fn setup(len: usize) -> (Vec<f64>, Vec<f64>) {
    let mut rng = rand::thread_rng();

    let m1: Vec<f64> = (0..len).map(|_| rng.gen_range(0..10) as f64).collect();
    let m2: Vec<f64> = (0..len).map(|_| rng.gen_range(0..10) as f64).collect();

    (m1, m2)
}

#[bench]
fn matrix_simple_multiplication_bench(b: &mut Bencher) {
    let (m1, m2) = setup(3000 * 32);

    let matrix1 = Matrix::new(3000, 32, m1).unwrap();
    let matrix2 = Matrix::new(32, 3000, m2).unwrap();

    b.iter(|| {
        matrix1.simple_product_matrix(&matrix2);
    })
}

#[bench]
fn matrix_trivial_big_multiplication_bench(b: &mut Bencher) {
    let (m1, m2) = setup(384 * 384);

    let matrix1 = Matrix::new(384, 384, m1).unwrap();
    let matrix2 = Matrix::new(384, 384, m2).unwrap();

    b.iter(|| matrix1.trivial_product_matrix(&matrix2))
}

#[bench]
fn matrix_trivial_multiplication_bench(b: &mut Bencher) {
    let (m1, m2) = setup(3000 * 32);

    let matrix1 = Matrix::new(3000, 32, m1).unwrap();
    let matrix2 = Matrix::new(32, 3000, m2).unwrap();

    b.iter(|| {
        matrix1.trivial_product_matrix(&matrix2);
    })
}

#[bench]
fn matrix_trivial_multiplication_small_bench(b: &mut Bencher) {
    let (m1, m2) = setup(40 * 40);

    let matrix1 = Matrix::new(40, 40, m1).unwrap();
    let matrix2 = Matrix::new(40, 40, m2).unwrap();

    b.iter(|| {
        matrix1.trivial_product_matrix(&matrix2);
    })
}

#[bench]
fn matrix_multiplication_384_bench(b: &mut Bencher) {
    let (m1, m2) = setup(384 * 384);

    let matrix1 = Matrix::new(384, 384, m1).unwrap();
    let matrix2 = Matrix::new(384, 384, m2).unwrap();

    b.iter(|| matrix1.product_matrix(&matrix2))
}

#[test]
fn big_matrix_multiplication_test() {
    let pre_random = Instant::now();
    let (m1, m2) = setup(3000 * 32);
    println!("{}", pre_random.elapsed().as_millis());

    let multiplication = Instant::now();
    let matrix1 = Matrix::new(3000, 32, m1).unwrap();
    let matrix2 = Matrix::new(32, 3000, m2).unwrap();

    matrix1.product_matrix(&matrix2);

    println!("{}", multiplication.elapsed().as_millis())
}

#[cfg(feature = "simd")]
mod simd_tests {
    use super::*;
    #[bench]
    fn simd_f64_matrix_multiplication_1k_bench(b: &mut Bencher) {
        let (m1, m2) = setup(1024 * 1024);

        let matrix1 = Matrix::new(1024, 1024, m1).unwrap();
        let matrix2 = Matrix::new(1024, 1024, m2).unwrap();

        b.iter(|| {
            let _ = matrix1.simd_product_matrix(&matrix2);
        })
    }

    #[bench]
    fn simd_f64_matrix_multiplication_384_bench(b: &mut Bencher) {
        let (m1, m2) = setup(384 * 384);

        let matrix1 = Matrix::new(384, 384, m1).unwrap();
        let matrix2 = Matrix::new(384, 384, m2).unwrap();

        b.iter(|| matrix1.simd_product_matrix(&matrix2))
    }

    #[bench]
    fn simd_f32_matrix_multiplication_384_bench(b: &mut Bencher) {
        let (m1, m2) = setup(384 * 384);
        let m1_32: Vec<f32> = m1.iter().map(|x| *x as f32).collect();
        let m2_32: Vec<f32> = m2.iter().map(|x| *x as f32).collect();

        let matrix1 = Matrix::new(384, 384, m1_32).unwrap();
        let matrix2 = Matrix::new(384, 384, m2_32).unwrap();

        b.iter(|| matrix1.simd_product_matrix(&matrix2))
    }
}