csvbinmatrix 0.8.0

Binary matrix Compressed Sparse Vector
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

//! Comparison module

use super::CSVBinaryMatrix;

impl PartialEq for CSVBinaryMatrix {
    fn eq(self: &CSVBinaryMatrix, other: &CSVBinaryMatrix) -> bool {
        if self.number_of_rows != other.number_of_rows {
            return false;
        }
        if self.number_of_columns != other.number_of_columns {
            return false;
        }
        if self.distances.len() != other.distances.len() {
            return false;
        }
        if self.is_reversed == other.is_reversed {
            return self.distances == other.distances;
        }
        let mut distance_index = 0;
        let mut rev_distance_index = other.distances.len();
        while distance_index < self.distances.len() {
            if self.distances[distance_index] != other.distances[rev_distance_index - 1] {
                return false;
            }
            distance_index += 1;
            rev_distance_index -= 1;
        }
        true
    }
}

#[cfg(test)]
mod tests {
    use pretty_assertions::assert_eq;
    use rstest::rstest;

    use super::super::ops::tests::matrix_a_rev;
    use super::super::tests::{matrix_a, matrix_a_bis};
    use super::super::CSVBinaryMatrix;

    #[rstest]
    fn no_equal_number_of_rows(matrix_a: CSVBinaryMatrix) {
        let matrix_b = CSVBinaryMatrix::try_from(&[[1, 1, 1]]).unwrap();
        assert!(matrix_a != matrix_b);
    }

    #[rstest]
    fn no_equal_number_of_columns(matrix_a: CSVBinaryMatrix) {
        let matrix_b = CSVBinaryMatrix::try_from(&[[1, 1], [1, 0], [0, 1]]).unwrap();
        assert!(matrix_a != matrix_b);
    }

    #[rstest]
    fn no_equal_distances(matrix_a: CSVBinaryMatrix) {
        let matrix_b = CSVBinaryMatrix::try_from(&[[1, 1, 1], [1, 0, 1], [0, 1, 0]]).unwrap();
        assert!(matrix_a != matrix_b);
    }

    #[rstest]
    fn equal_when_rev_bools_equal(matrix_a: CSVBinaryMatrix) {
        let matrix_b = matrix_a.clone();
        assert_eq!(matrix_a, matrix_b);
    }

    #[rstest]
    fn equal_when_rev_bools_differ(matrix_a: CSVBinaryMatrix, matrix_a_bis: CSVBinaryMatrix) {
        assert_eq!(matrix_a, matrix_a_bis);
    }

    #[rstest]
    fn no_equal_when_rev_bools_differ(matrix_a: CSVBinaryMatrix, matrix_a_rev: CSVBinaryMatrix) {
        assert!(matrix_a != matrix_a_rev);
    }
}