geometric-traits 0.2.3

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
112
113
114
115

//! Trait defining a bidimensional matrix.

use multi_ranged::{SimpleRange, Step};
use num_traits::{AsPrimitive, Zero};

use super::SquareMatrix;
use crate::traits::{Matrix, PositiveInteger};

/// Trait defining a bidimensional matrix.
pub trait Matrix2D:
    Matrix<Coordinates = (<Self as Matrix2D>::RowIndex, <Self as Matrix2D>::ColumnIndex)>
{
    /// Type of the row index.
    type RowIndex: Step + PositiveInteger + AsPrimitive<usize>;
    /// Type of the column index.
    type ColumnIndex: Step + PositiveInteger + AsPrimitive<usize>;

    /// Returns the number of rows of the matrix.
    fn number_of_rows(&self) -> Self::RowIndex;

    /// Returns the number of columns of the matrix.
    fn number_of_columns(&self) -> Self::ColumnIndex;

    #[inline]
    /// Returns an iterator over the rows of the matrix.
    fn row_indices(&self) -> SimpleRange<Self::RowIndex> {
        let number_of_rows = self.number_of_rows();
        if number_of_rows.is_zero() {
            SimpleRange::default()
        } else {
            SimpleRange::try_from((Self::RowIndex::zero(), number_of_rows.prev()))
                .expect("zero <= number_of_rows - 1 holds when number_of_rows > 0")
        }
    }

    #[inline]
    /// Returns an iterator over the columns of the matrix.
    fn column_indices(&self) -> SimpleRange<Self::ColumnIndex> {
        let number_of_columns = self.number_of_columns();
        if number_of_columns.is_zero() {
            SimpleRange::default()
        } else {
            SimpleRange::try_from((Self::ColumnIndex::zero(), number_of_columns.prev()))
                .expect("zero <= number_of_columns - 1 holds when number_of_columns > 0")
        }
    }
}

impl<M: Matrix2D> Matrix2D for &M {
    type RowIndex = M::RowIndex;
    type ColumnIndex = M::ColumnIndex;

    #[inline]
    fn number_of_rows(&self) -> Self::RowIndex {
        (*self).number_of_rows()
    }

    #[inline]
    fn number_of_columns(&self) -> Self::ColumnIndex {
        (*self).number_of_columns()
    }
}

/// Trait defining a bidimensional matrix which can return references to
/// the number of rows and columns.
pub trait Matrix2DRef: Matrix2D {
    /// Returns a reference to the number of rows of the matrix.
    fn number_of_rows_ref(&self) -> &Self::RowIndex;

    /// Returns a reference to the number of columns of the matrix.
    fn number_of_columns_ref(&self) -> &Self::ColumnIndex;
}

/// Trait defining a transposable bidimensional matrix.
pub trait TransposableMatrix2D<
    Transposed: Matrix2D<RowIndex = Self::ColumnIndex, ColumnIndex = Self::RowIndex>,
>: Matrix2D
{
    /// Returns the transpose of the matrix.
    fn transpose(&self) -> Transposed;
}

/// Trait defining a matrix which supports efficient operations on columns.
pub trait BiMatrix2D: Matrix2D {
    /// The type of the underlying matrix.
    type Matrix: Matrix2D<RowIndex = Self::RowIndex, ColumnIndex = Self::ColumnIndex>;
    /// The type of the underlying transposed matrix.
    type TransposedMatrix: Matrix2D<RowIndex = Self::ColumnIndex, ColumnIndex = Self::RowIndex>;

    /// Returns a reference to the underlying matrix.
    fn matrix(&self) -> &Self::Matrix;

    /// Returns a reference to the underlying transposed matrix.
    fn transposed(&self) -> &Self::TransposedMatrix;
}

/// Trait defining a symmetric matrix.
pub trait SymmetricMatrix2D:
    SquareMatrix
    + BiMatrix2D<
        Matrix = <Self as SymmetricMatrix2D>::SymmetricMatrix,
        TransposedMatrix = <Self as SymmetricMatrix2D>::SymmetricMatrix,
    >
{
    /// The underlying symmetric matrix type.
    type SymmetricMatrix: Matrix2D<RowIndex = Self::Index, ColumnIndex = Self::Index>;
}

impl<M> SymmetricMatrix2D for M
where
    M: SquareMatrix + BiMatrix2D<TransposedMatrix = <M as BiMatrix2D>::Matrix>,
    M::Matrix: Matrix2D<RowIndex = Self::RowIndex, ColumnIndex = Self::ColumnIndex>,
{
    type SymmetricMatrix = M::Matrix;
}