geometric-traits 0.2.0

Trait-based algebraic and graph algorithms for Rust, supporting no_std environments
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

//! Submodule providing traits for reference access to sparse valued matrix
//! values.

use super::ValuedMatrix2D;
use crate::traits::{SparseValuedMatrix2D, SparseValuedMatrixRef, ValuedMatrix};

/// Trait defining reference access to values in a sparse bi-dimensional matrix.
///
/// Unlike [`SparseValuedMatrix2D`] which returns cloned values, this trait
/// provides direct references to the stored values, avoiding copies for
/// non-`Copy` types.
pub trait SparseValuedMatrix2DRef:
    SparseValuedMatrix2D + ValuedMatrix2D + SparseValuedMatrixRef
{
    /// Iterator over references to the values of a row.
    type SparseRowValuesRef<'a>: Iterator<Item = &'a <Self as ValuedMatrix>::Value>
        + DoubleEndedIterator<Item = &'a <Self as ValuedMatrix>::Value>
    where
        Self: 'a,
        <Self as ValuedMatrix>::Value: 'a;

    /// Returns an iterator over references to the values of a row.
    ///
    /// # Arguments
    ///
    /// * `row`: The row.
    fn sparse_row_values_ref(&self, row: Self::RowIndex) -> Self::SparseRowValuesRef<'_>;

    /// Returns a reference to the value at the given row and column, if
    /// present.
    #[inline]
    fn sparse_value_at_ref(
        &self,
        row: Self::RowIndex,
        column: Self::ColumnIndex,
    ) -> Option<&<Self as ValuedMatrix>::Value>
    where
        Self::ColumnIndex: PartialEq,
    {
        self.sparse_row(row)
            .zip(self.sparse_row_values_ref(row))
            .find(|&(col, _)| col == column)
            .map(|(_, val)| val)
    }

    /// Returns an iterator over the entries (column index and value reference)
    /// of a row.
    #[inline]
    fn sparse_row_entries(
        &self,
        row: Self::RowIndex,
    ) -> impl Iterator<Item = (Self::ColumnIndex, &<Self as ValuedMatrix>::Value)> {
        self.sparse_row(row).zip(self.sparse_row_values_ref(row))
    }
}

impl<M: SparseValuedMatrix2DRef> SparseValuedMatrix2DRef for &M {
    type SparseRowValuesRef<'a>
        = M::SparseRowValuesRef<'a>
    where
        Self: 'a,
        M::Value: 'a;

    #[inline]
    fn sparse_row_values_ref(&self, row: Self::RowIndex) -> Self::SparseRowValuesRef<'_> {
        (*self).sparse_row_values_ref(row)
    }

    #[inline]
    fn sparse_value_at_ref(
        &self,
        row: Self::RowIndex,
        column: Self::ColumnIndex,
    ) -> Option<&<Self as ValuedMatrix>::Value>
    where
        Self::ColumnIndex: PartialEq,
    {
        (*self).sparse_value_at_ref(row, column)
    }
}