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

• Associated data `N` for nodes and `E` for edges, called weights. The associated data can be of arbitrary type.
• Edge type `Ty` that determines whether the graph edges are directed or undirected.
• Index type `Ix`, which determines the maximum size of the graph.

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

Self loops are allowed, no parallel edges.

Fast iteration of the outgoing edges of a vertex. [`CSR`]: https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format)

## Methods

### `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]

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.

#### ⓘImportant traits for Edges<'a, E, Ty, Ix>### Important 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>;``pub fn edges(&self, a: NodeIndex<Ix>) -> Edges<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: Debug, E: Debug, Ty: Debug, Ix: Debug> Debug for Csr<N, E, Ty, Ix>`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

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

#### `fn default() -> Self`[src]

Returns the "default value" for a type. Read more

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

#### `fn clone(&self) -> Self`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

node identifier

edge identifier

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

#### `fn visit_map(&self) -> FixedBitSet`[src]

Create a new visitor map

#### `fn reset_map(&self, map: &mut Self::Map)`[src]

Reset the visitor map (and resize to new size of graph if needed)

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

#### `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<N, E, Ty, Ix> NodeIndexable for Csr<N, E, Ty, Ix> where    Ty: EdgeType,    Ix: IndexType, `[src]

#### `fn node_bound(&self) -> usize`[src]

Return an upper bound of the node indices in the graph (suitable for the size of a bitmap). Read more

#### `fn to_index(&self, a: Self::NodeId) -> usize`[src]

Convert `a` to an integer index.

#### `fn from_index(&self, ix: usize) -> Self::NodeId`[src]

Convert `i` to a node index

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

#### `type Output = N`

The returned type after indexing.

#### `fn index(&self, ix: NodeIndex<Ix>) -> &N`[src]

Performs the indexing (`container[index]`) operation.

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

#### `fn index_mut(&mut self, ix: NodeIndex<Ix>) -> &mut N`[src]

Performs the mutable indexing (`container[index]`) operation.

### `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.