Struct petgraph::csr::Csr[][src]

pub struct Csr<N = (), E = (), Ty = Directed, Ix = DefaultIx> { /* fields omitted */ }

Compressed Sparse Row (CSR) is a sparse adjacency matrix graph.

CSR is parameterized over:

Using O(|E| + |V|) space.

Self loops are allowed, no parallel edges.

Fast iteration of the outgoing edges of a vertex.

Implementations

impl<N, E, Ty, Ix> Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

pub fn new() -> Self[src]

Create an empty Csr.

pub fn with_nodes(n: usize) -> Self where
    N: Default
[src]

Create a new Csr with n nodes. N must implement Default for the weight of each node.

Example

use petgraph::csr::Csr;
use petgraph::prelude::*;

let graph = Csr::<u8,()>::with_nodes(5);
assert_eq!(graph.node_count(),5);
assert_eq!(graph.edge_count(),0);

assert_eq!(graph[0],0);
assert_eq!(graph[4],0);

impl<N, E, Ix> Csr<N, E, Directed, Ix> where
    Ix: IndexType
[src]

pub fn from_sorted_edges<Edge>(edges: &[Edge]) -> Result<Self, EdgesNotSorted> where
    Edge: Clone + IntoWeightedEdge<E, NodeId = NodeIndex<Ix>>,
    N: Default
[src]

Create a new Csr from a sorted sequence of edges

Edges must be sorted and unique, where the sort order is the default order for the pair (u, v) in Rust (u has priority).

Computes in O(|E| + |V|) time.

Example

use petgraph::csr::Csr;
use petgraph::prelude::*;

let graph = Csr::<(),()>::from_sorted_edges(&[
                    (0, 1), (0, 2),
                    (1, 0), (1, 2), (1, 3),
                    (2, 0),
                    (3, 1),
]);

impl<N, E, Ty, Ix> Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

pub fn node_count(&self) -> usize[src]

pub fn edge_count(&self) -> usize[src]

pub fn is_directed(&self) -> bool[src]

pub fn clear_edges(&mut self)[src]

Remove all edges

pub fn add_node(&mut self, weight: N) -> NodeIndex<Ix>[src]

Adds a new node with the given weight, returning the corresponding node index.

pub fn add_edge(
    &mut self,
    a: NodeIndex<Ix>,
    b: NodeIndex<Ix>,
    weight: E
) -> bool where
    E: Clone
[src]

Return true if the edge was added

If you add all edges in row-major order, the time complexity is O(|V|·|E|) for the whole operation.

Panics if a or b are out of bounds.

pub fn contains_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool[src]

Computes in O(log |V|) time.

Panics if the node a does not exist.

pub fn out_degree(&self, a: NodeIndex<Ix>) -> usize[src]

Computes in O(1) time.

Panics if the node a does not exist.

pub fn neighbors_slice(&self, a: NodeIndex<Ix>) -> &[NodeIndex<Ix>][src]

Computes in O(1) time.

Panics if the node a does not exist.

pub fn edges_slice(&self, a: NodeIndex<Ix>) -> &[E][src]

Computes in O(1) time.

Panics if the node a does not exist.

pub fn edges(&self, a: NodeIndex<Ix>) -> Edges<'_, E, Ty, Ix>

Notable traits for Edges<'a, E, Ty, Ix>

impl<'a, E, Ty, Ix> Iterator for Edges<'a, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
type Item = EdgeReference<'a, E, Ty, Ix>;
[src]

Return an iterator of all edges of a.

  • Directed: Outgoing edges from a.
  • Undirected: All edges connected to a.

Panics if the node a does not exist.
Iterator element type is EdgeReference<E, Ty, Ix>.

Trait Implementations

impl<N: Clone, E: Clone, Ty, Ix: Clone> Clone for Csr<N, E, Ty, Ix>[src]

impl<N, E, Ty, Ix> Data for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type NodeWeight = N

type EdgeWeight = E

impl<N: Debug, E: Debug, Ty: Debug, Ix: Debug> Debug for Csr<N, E, Ty, Ix>[src]

impl<N, E, Ty, Ix> Default for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> GraphBase for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type NodeId = NodeIndex<Ix>

node identifier

type EdgeId = EdgeIndex

edge identifier

impl<N, E, Ty, Ix> GraphProp for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type EdgeType = Ty

The kind edges in the graph.

impl<N, E, Ty, Ix> Index<Ix> for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type Output = N

The returned type after indexing.

impl<N, E, Ty, Ix> IndexMut<Ix> for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<'a, N, E, Ty, Ix> IntoEdgeReferences for &'a Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type EdgeRef = EdgeReference<'a, E, Ty, Ix>

type EdgeReferences = EdgeReferences<'a, E, Ty, Ix>

impl<'a, N, E, Ty, Ix> IntoEdges for &'a Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type Edges = Edges<'a, E, Ty, Ix>

impl<'a, N, E, Ty, Ix> IntoNeighbors for &'a Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type Neighbors = Neighbors<'a, Ix>

fn neighbors(self, a: Self::NodeId) -> Self::Neighbors[src]

Return an iterator of all neighbors of a.

  • Directed: Targets of outgoing edges from a.
  • Undirected: Opposing endpoints of all edges connected to a.

Panics if the node a does not exist.
Iterator element type is NodeIndex<Ix>.

impl<'a, N, E, Ty, Ix> IntoNodeIdentifiers for &'a Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> NodeCount for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> NodeIndexable for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> Visitable for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

type Map = FixedBitSet

The associated map type

impl<N, E, Ty, Ix> NodeCompactIndexable for Csr<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Auto Trait Implementations

impl<N, E, Ty, Ix> RefUnwindSafe for Csr<N, E, Ty, Ix> where
    E: RefUnwindSafe,
    Ix: RefUnwindSafe,
    N: RefUnwindSafe,
    Ty: RefUnwindSafe

impl<N, E, Ty, Ix> Send for Csr<N, E, Ty, Ix> where
    E: Send,
    Ix: Send,
    N: Send,
    Ty: Send

impl<N, E, Ty, Ix> Sync for Csr<N, E, Ty, Ix> where
    E: Sync,
    Ix: Sync,
    N: Sync,
    Ty: Sync

impl<N, E, Ty, Ix> Unpin for Csr<N, E, Ty, Ix> where
    E: Unpin,
    Ix: Unpin,
    N: Unpin,
    Ty: Unpin

impl<N, E, Ty, Ix> UnwindSafe for Csr<N, E, Ty, Ix> where
    E: UnwindSafe,
    Ix: UnwindSafe,
    N: UnwindSafe,
    Ty: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Pointable for T[src]

type Init = T

The type for initializers.

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.