matrix 0.22.0

The package provides a matrix laboratory.
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

use random::{self, Source};
use test::Bencher;

use matrix::format::compressed::Variant;
use matrix::format::{Compressed, Conventional};
use matrix::operation::MultiplyInto;

#[bench]
fn multiply_left_0010(b: &mut Bencher) {
    multiply_left(10, 10, b);
}

#[bench]
fn multiply_left_0100(b: &mut Bencher) {
    multiply_left(100, 100, b);
}

#[bench]
fn multiply_left_1000(b: &mut Bencher) {
    multiply_left(1000, 1000, b);
}

#[bench]
fn multiply_left_0010_dense(b: &mut Bencher) {
    multiply_left_dense(10, 10, b);
}

#[bench]
fn multiply_left_0100_dense(b: &mut Bencher) {
    multiply_left_dense(100, 100, b);
}

#[bench]
fn multiply_left_1000_dense(b: &mut Bencher) {
    multiply_left_dense(1000, 1000, b);
}

#[bench]
fn multiply_right_0010(b: &mut Bencher) {
    multiply_right(10, 10, b);
}

#[bench]
fn multiply_right_0100(b: &mut Bencher) {
    multiply_right(100, 100, b);
}

#[bench]
fn multiply_right_1000(b: &mut Bencher) {
    multiply_right(1000, 1000, b);
}

#[bench]
fn multiply_right_0010_dense(b: &mut Bencher) {
    multiply_right_dense(10, 10, b);
}

#[bench]
fn multiply_right_0100_dense(b: &mut Bencher) {
    multiply_right_dense(100, 100, b);
}

#[bench]
fn multiply_right_1000_dense(b: &mut Bencher) {
    multiply_right_dense(1000, 1000, b);
}

fn multiply_left(size: usize, nonzeros: usize, bencher: &mut Bencher) {
    let left = make_compressed(size, size, nonzeros);
    let right = make_conventional(size, size);
    let mut result = Conventional::new(size);
    bencher.iter(|| left.multiply_into(&right, &mut result));
}

fn multiply_left_dense(size: usize, nonzeros: usize, bencher: &mut Bencher) {
    let left = Conventional::from(make_compressed(size, size, nonzeros));
    let right = make_conventional(size, size);
    let mut result = Conventional::new(size);
    bencher.iter(|| left.multiply_into(&right, &mut result));
}

fn multiply_right(size: usize, nonzeros: usize, bencher: &mut Bencher) {
    let left = make_conventional(size, size);
    let right = make_compressed(size, size, nonzeros);
    let mut result = Conventional::new(size);
    bencher.iter(|| left.multiply_into(&right, &mut result));
}

fn multiply_right_dense(size: usize, nonzeros: usize, bencher: &mut Bencher) {
    let left = make_conventional(size, size);
    let right = Conventional::from(&make_compressed(size, size, nonzeros));
    let mut result = Conventional::new(size);
    bencher.iter(|| left.multiply_into(&right, &mut result));
}

fn make_compressed(rows: usize, columns: usize, nonzeros: usize) -> Compressed<f64> {
    let mut source = random::default().seed([42, 69]);
    let mut matrix = Compressed::with_capacity((rows, columns), Variant::Column, nonzeros);
    for _ in 0..nonzeros {
        let i = source.read::<u64>() as usize % rows;
        let j = source.read::<u64>() as usize % columns;
        matrix.set((i, j), source.read::<f64>());
    }
    matrix
}

fn make_conventional(rows: usize, columns: usize) -> Conventional<f64> {
    let mut source = random::default().seed([69, 42]);
    let values = source.iter().take(rows * columns).collect::<Vec<f64>>();
    Conventional::from_vec((rows, columns), values)
}