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
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

//! Submodule implementing Edges for `GenericBiMatrix2D`.

use num_traits::Zero;

use crate::{
    impls::GenericBiMatrix2D,
    traits::{
        Edges, Graph, Matrix, Matrix2D, MonoplexGraph, SizedRowsSparseMatrix2D, SizedSparseMatrix,
        SparseMatrix, TransposableMatrix2D, TryFromUsize,
    },
};

impl<M, T> Edges for GenericBiMatrix2D<M, T>
where
    M: Matrix2D<ColumnIndex = <M as Matrix2D>::RowIndex>
        + Edges<
            Edge = <M as Matrix>::Coordinates,
            SourceNodeId = <M as Matrix2D>::RowIndex,
            DestinationNodeId = <M as Matrix2D>::RowIndex,
            EdgeId = <M as SparseMatrix>::SparseIndex,
            Matrix = M,
        > + SizedRowsSparseMatrix2D,
    T: Matrix2D<RowIndex = <M as Matrix2D>::RowIndex, ColumnIndex = <M as Matrix2D>::ColumnIndex>
        + Edges<
            Edge = <M as Edges>::Edge,
            SourceNodeId = <M as Edges>::SourceNodeId,
            DestinationNodeId = <M as Edges>::DestinationNodeId,
            EdgeId = <M as Edges>::EdgeId,
            Matrix = T,
        > + SizedRowsSparseMatrix2D,
    M: TransposableMatrix2D<T>,
    <M as Matrix2D>::RowIndex: TryFromUsize,
    <M as SparseMatrix>::SparseIndex: TryFromUsize,
{
    type Edge = <M as Edges>::Edge;
    type SourceNodeId = <M as Edges>::SourceNodeId;
    type DestinationNodeId = <M as Edges>::DestinationNodeId;
    type EdgeId = <M as Edges>::EdgeId;
    type Matrix = Self;

    #[inline]
    fn matrix(&self) -> &Self::Matrix {
        self
    }
}

impl<M, T> Graph for GenericBiMatrix2D<M, T>
where
    M: Matrix2D<ColumnIndex = <M as Matrix2D>::RowIndex>
        + Edges<
            Edge = <M as Matrix>::Coordinates,
            SourceNodeId = <M as Matrix2D>::RowIndex,
            DestinationNodeId = <M as Matrix2D>::RowIndex,
            EdgeId = <M as SparseMatrix>::SparseIndex,
            Matrix = M,
        > + SizedRowsSparseMatrix2D,
    T: Matrix2D<RowIndex = <M as Matrix2D>::RowIndex, ColumnIndex = <M as Matrix2D>::ColumnIndex>
        + Edges<
            Edge = <M as Edges>::Edge,
            SourceNodeId = <M as Edges>::SourceNodeId,
            DestinationNodeId = <M as Edges>::DestinationNodeId,
            EdgeId = <M as Edges>::EdgeId,
            Matrix = T,
        > + SizedRowsSparseMatrix2D,
    M: TransposableMatrix2D<T>,
    <M as Matrix2D>::RowIndex: TryFromUsize,
    <M as SparseMatrix>::SparseIndex: TryFromUsize,
{
    #[inline]
    fn has_nodes(&self) -> bool {
        self.number_of_rows() > <M as Matrix2D>::RowIndex::zero()
            && self.number_of_columns() > <M as Matrix2D>::RowIndex::zero()
    }

    #[inline]
    fn has_edges(&self) -> bool {
        self.number_of_defined_values() > <M as SparseMatrix>::SparseIndex::zero()
    }
}

impl<M, T> MonoplexGraph for GenericBiMatrix2D<M, T>
where
    M: Matrix2D<ColumnIndex = <M as Matrix2D>::RowIndex>
        + Edges<
            Edge = <M as Matrix>::Coordinates,
            SourceNodeId = <M as Matrix2D>::RowIndex,
            DestinationNodeId = <M as Matrix2D>::RowIndex,
            EdgeId = <M as SparseMatrix>::SparseIndex,
            Matrix = M,
        > + SizedRowsSparseMatrix2D,
    T: Matrix2D<RowIndex = <M as Matrix2D>::RowIndex, ColumnIndex = <M as Matrix2D>::ColumnIndex>
        + Edges<
            Edge = <M as Edges>::Edge,
            SourceNodeId = <M as Edges>::SourceNodeId,
            DestinationNodeId = <M as Edges>::DestinationNodeId,
            EdgeId = <M as Edges>::EdgeId,
            Matrix = T,
        > + SizedRowsSparseMatrix2D,
    M: TransposableMatrix2D<T>,
    <M as Matrix2D>::RowIndex: TryFromUsize,
    <M as SparseMatrix>::SparseIndex: TryFromUsize,
{
    type Edge = <Self as Matrix>::Coordinates;
    type Edges = Self;

    #[inline]
    fn edges(&self) -> &Self::Edges {
        self
    }
}