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

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

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

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

node identifier

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

#### `type Map = FixedBitSet`

The associated map type

## Blanket Implementations

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