geometric-traits 0.1.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
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

//! Submodule providing traits to represent a dense valued matrix.
//!
//! A dense valued matrix is a matrix where all the values are defined.

use super::ValuedMatrix2D;
use crate::traits::{DenseMatrix2D, DenseValuedMatrix, TotalOrd, ValuedMatrix};

/// Trait defining a bi-dimensional matrix.
pub trait DenseValuedMatrix2D: DenseMatrix2D + ValuedMatrix2D + DenseValuedMatrix {
    /// Iterator over the values of a row.
    type RowValues<'a>: Iterator<Item = <Self as ValuedMatrix>::Value>
        + DoubleEndedIterator<Item = <Self as ValuedMatrix>::Value>
        + Clone
    where
        Self: 'a;

    #[inline]
    /// Returns the maximal value on the row.
    ///
    /// # Arguments
    ///
    /// * `row`: The row.
    ///
    /// # Returns
    ///
    /// The maximal value on the row, if the row has at least one value.
    fn row_max_value(&self, row: Self::RowIndex) -> Option<<Self as ValuedMatrix>::Value>
    where
        Self::Value: TotalOrd,
    {
        self.row_values(row).max_by(TotalOrd::total_cmp)
    }

    #[inline]
    /// Returns the maximal value and its column on the row.
    ///
    /// # Arguments
    ///
    /// * `row`: The row.
    ///
    /// # Returns
    ///
    /// The maximal value and its column on the row,
    /// if the row has at least one value.
    fn row_max_value_and_column(
        &self,
        row: Self::RowIndex,
    ) -> Option<(Self::ColumnIndex, Self::Value)>
    where
        Self::Value: TotalOrd,
    {
        self.column_indices()
            .zip(self.row_values(row))
            .max_by(|(_, value1), (_, value2)| value1.total_cmp(value2))
    }

    #[inline]
    /// Returns the minimal value on the row.
    ///
    /// # Arguments
    ///
    /// * `row`: The row.
    ///
    /// # Returns
    ///
    /// The minimal value on the row, if the row has at least one value.
    fn row_min_value(&self, row: Self::RowIndex) -> Option<<Self as ValuedMatrix>::Value>
    where
        Self::Value: TotalOrd,
    {
        self.row_values(row).min_by(TotalOrd::total_cmp)
    }

    #[inline]
    /// Returns the minimal value and its column on the row.
    ///
    /// # Arguments
    ///
    /// * `row`: The row.
    ///
    /// # Returns
    ///
    /// The minimal value and its column on the row,
    /// if the row has at least one value.
    fn row_min_value_and_column(
        &self,
        row: Self::RowIndex,
    ) -> Option<(Self::ColumnIndex, Self::Value)>
    where
        Self::Value: TotalOrd,
    {
        self.column_indices()
            .zip(self.row_values(row))
            .min_by(|(_, value1), (_, value2)| value1.total_cmp(value2))
    }

    /// Returns an iterator of the values of the row.
    fn row_values(&self, row: Self::RowIndex) -> Self::RowValues<'_>;
}

impl<M: DenseValuedMatrix2D> DenseValuedMatrix2D for &M {
    type RowValues<'a>
        = M::RowValues<'a>
    where
        Self: 'a;

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