Struct cagra::graph::Graph
[−]
[src]
pub struct Graph<A: Scalar>(_);
Calculation graph based on petgraph::graph::Graph
Methods
impl<A: Scalar> Graph<A>
[src]
fn new() -> Self
[src]
new graph.
fn variable(&mut self, name: &str) -> NodeIndex
[src]
Create new empty variable
fn scalar_variable(&mut self, name: &str, value: A) -> NodeIndex
[src]
Create new scalar variable
fn vector_variable(&mut self, name: &str, value: Array<A, Ix1>) -> NodeIndex
[src]
Create new vector variable
fn set_value<V: Into<Value<A>>>(
&mut self,
node: NodeIndex,
value: V
) -> Result<()>
[src]
&mut self,
node: NodeIndex,
value: V
) -> Result<()>
Set a value to a variable node, and returns NodeTypeError
if the node is an operator.
fn add(&mut self, lhs: NodeIndex, rhs: NodeIndex) -> NodeIndex
[src]
fn neg(&mut self, arg: NodeIndex) -> NodeIndex
[src]
fn sub(&mut self, lhs: NodeIndex, rhs: NodeIndex) -> NodeIndex
[src]
fn get_value(&self, node: NodeIndex) -> Option<&Value<A>>
[src]
Get the value of the node. If the value has not been caluclated,
returns None
fn get_deriv(&self, node: NodeIndex) -> Option<&Value<A>>
[src]
Get the value of the node. If the value has not been caluclated,
returns None
fn eval_value(&mut self, node: NodeIndex, use_cached: bool) -> Result<()>
[src]
Evaluate the value of the node recusively.
use_cached
- Use the value if already calculated.
fn eval_deriv(&mut self, node: NodeIndex) -> Result<()>
[src]
Evaluate derivative recursively.
Methods from Deref<Target = Graph<Node<A>, ()>>
fn node_count(&self) -> usize
[src]
Return the number of nodes (vertices) in the graph.
Computes in O(1) time.
fn edge_count(&self) -> usize
[src]
Return the number of edges in the graph.
Computes in O(1) time.
fn is_directed(&self) -> bool
[src]
Whether the graph has directed edges or not.
fn add_node(&mut self, weight: N) -> NodeIndex<Ix>
[src]
Add a node (also called vertex) with associated data weight
to the graph.
Computes in O(1) time.
Return the index of the new node.
Panics if the Graph is at the maximum number of nodes for its index type (N/A if usize).
fn node_weight(&self, a: NodeIndex<Ix>) -> Option<&N>
[src]
Access the weight for node a
.
Also available with indexing syntax: &graph[a]
.
fn node_weight_mut(&mut self, a: NodeIndex<Ix>) -> Option<&mut N>
[src]
Access the weight for node a
, mutably.
Also available with indexing syntax: &mut graph[a]
.
fn add_edge(
&mut self,
a: NodeIndex<Ix>,
b: NodeIndex<Ix>,
weight: E
) -> EdgeIndex<Ix>
[src]
&mut self,
a: NodeIndex<Ix>,
b: NodeIndex<Ix>,
weight: E
) -> EdgeIndex<Ix>
Add an edge from a
to b
to the graph, with its associated
data weight
.
Return the index of the new edge.
Computes in O(1) time.
Panics if any of the nodes don't exist.
Panics if the Graph is at the maximum number of edges for its index
type (N/A if usize).
Note: Graph
allows adding parallel (“duplicate”) edges. If you want
to avoid this, use .update_edge(a, b, weight)
instead.
fn update_edge(
&mut self,
a: NodeIndex<Ix>,
b: NodeIndex<Ix>,
weight: E
) -> EdgeIndex<Ix>
[src]
&mut self,
a: NodeIndex<Ix>,
b: NodeIndex<Ix>,
weight: E
) -> EdgeIndex<Ix>
Add or update an edge from a
to b
.
If the edge already exists, its weight is updated.
Return the index of the affected edge.
Computes in O(e') time, where e' is the number of edges
connected to a
(and b
, if the graph edges are undirected).
Panics if any of the nodes don't exist.
fn edge_weight(&self, e: EdgeIndex<Ix>) -> Option<&E>
[src]
Access the weight for edge e
.
Also available with indexing syntax: &graph[e]
.
fn edge_weight_mut(&mut self, e: EdgeIndex<Ix>) -> Option<&mut E>
[src]
Access the weight for edge e
, mutably.
Also available with indexing syntax: &mut graph[e]
.
fn edge_endpoints(
&self,
e: EdgeIndex<Ix>
) -> Option<(NodeIndex<Ix>, NodeIndex<Ix>)>
[src]
&self,
e: EdgeIndex<Ix>
) -> Option<(NodeIndex<Ix>, NodeIndex<Ix>)>
Access the source and target nodes for e
.
fn remove_node(&mut self, a: NodeIndex<Ix>) -> Option<N>
[src]
Remove a
from the graph if it exists, and return its weight.
If it doesn't exist in the graph, return None
.
Apart from a
, this invalidates the last node index in the graph
(that node will adopt the removed node index). Edge indices are
invalidated as they would be following the removal of each edge
with an endpoint in a
.
Computes in O(e') time, where e' is the number of affected
edges, including n calls to .remove_edge()
where n is the number
of edges with an endpoint in a
, and including the edges with an
endpoint in the displaced node.
fn remove_edge(&mut self, e: EdgeIndex<Ix>) -> Option<E>
[src]
Remove an edge and return its edge weight, or None
if it didn't exist.
Apart from e
, this invalidates the last edge index in the graph
(that edge will adopt the removed edge index).
Computes in O(e') time, where e' is the size of four particular edge lists, for
the vertices of e
and the vertices of another affected edge.
fn neighbors(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix>
[src]
Return an iterator of all nodes with an edge starting from a
.
Directed
: Outgoing edges froma
.Undirected
: All edges from or toa
.
Produces an empty iterator if the node doesn't exist.
Iterator element type is NodeIndex<Ix>
.
Use .neighbors(a).detach()
to get a neighbor walker that does
not borrow from the graph.
fn neighbors_directed(
&self,
a: NodeIndex<Ix>,
dir: Direction
) -> Neighbors<E, Ix>
[src]
&self,
a: NodeIndex<Ix>,
dir: Direction
) -> Neighbors<E, Ix>
Return an iterator of all neighbors that have an edge between them and
a
, in the specified direction.
If the graph's edges are undirected, this is equivalent to .neighbors(a).
Directed
,Outgoing
: All edges froma
.Directed
,Incoming
: All edges toa
.Undirected
: All edges from or toa
.
Produces an empty iterator if the node doesn't exist.
Iterator element type is NodeIndex<Ix>
.
For a Directed
graph, neighbors are listed in reverse order of their
addition to the graph, so the most recently added edge's neighbor is
listed first. The order in an Undirected
graph is arbitrary.
Use .neighbors_directed(a, dir).detach()
to get a neighbor walker that does
not borrow from the graph.
fn neighbors_undirected(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix>
[src]
Return an iterator of all neighbors that have an edge between them and
a
, in either direction.
If the graph's edges are undirected, this is equivalent to .neighbors(a).
Directed
andUndirected
: All edges from or toa
.
Produces an empty iterator if the node doesn't exist.
Iterator element type is NodeIndex<Ix>
.
Use .neighbors_undirected(a).detach()
to get a neighbor walker that does
not borrow from the graph.
fn edges(&self, a: NodeIndex<Ix>) -> Edges<E, Ty, Ix>
[src]
Return an iterator of all edges of a
.
Directed
: Outgoing edges froma
.Undirected
: All edges connected toa
.
Produces an empty iterator if the node doesn't exist.
Iterator element type is EdgeReference<E, Ix>
.
fn edges_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Edges<E, Ty, Ix>
[src]
Return an iterator of all edges of a
, in the specified direction.
Directed
,Outgoing
: All edges froma
.Directed
,Incoming
: All edges toa
.Undirected
: All edges connected toa
.
Produces an empty iterator if the node a
doesn't exist.
Iterator element type is EdgeReference<E, Ix>
.
fn contains_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool
[src]
Lookup if there is an edge from a
to b
.
Computes in O(e') time, where e' is the number of edges
connected to a
(and b
, if the graph edges are undirected).
fn find_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> Option<EdgeIndex<Ix>>
[src]
Lookup an edge from a
to b
.
Computes in O(e') time, where e' is the number of edges
connected to a
(and b
, if the graph edges are undirected).
fn find_edge_undirected(
&self,
a: NodeIndex<Ix>,
b: NodeIndex<Ix>
) -> Option<(EdgeIndex<Ix>, Direction)>
[src]
&self,
a: NodeIndex<Ix>,
b: NodeIndex<Ix>
) -> Option<(EdgeIndex<Ix>, Direction)>
Lookup an edge between a
and b
, in either direction.
If the graph is undirected, then this is equivalent to .find_edge()
.
Return the edge index and its directionality, with Outgoing
meaning
from a
to b
and Incoming
the reverse,
or None
if the edge does not exist.
fn externals(&self, dir: Direction) -> Externals<N, Ty, Ix>
[src]
Return an iterator over either the nodes without edges to them
(Incoming
) or from them (Outgoing
).
An internal node has both incoming and outgoing edges.
The nodes in .externals(Incoming)
are the source nodes and
.externals(Outgoing)
are the sinks of the graph.
For a graph with undirected edges, both the sinks and the sources are just the nodes without edges.
The whole iteration computes in O(|V|) time.
fn node_indices(&self) -> NodeIndices<Ix>
[src]
Return an iterator over the node indices of the graph
fn node_weights_mut(&mut self) -> NodeWeightsMut<N, Ix>
[src]
Return an iterator yielding mutable access to all node weights.
The order in which weights are yielded matches the order of their node indices.
fn edge_indices(&self) -> EdgeIndices<Ix>
[src]
Return an iterator over the edge indices of the graph
fn edge_references(&self) -> EdgeReferences<E, Ix>
[src]
Create an iterator over all edges, in indexed order.
Iterator element type is EdgeReference<E, Ix>
.
fn edge_weights_mut(&mut self) -> EdgeWeightsMut<E, Ix>
[src]
Return an iterator yielding mutable access to all edge weights.
The order in which weights are yielded matches the order of their edge indices.
fn raw_nodes(&self) -> &[Node<N, Ix>]
[src]
Access the internal node array.
fn raw_edges(&self) -> &[Edge<E, Ix>]
[src]
Access the internal edge array.
fn into_nodes_edges(self) -> (Vec<Node<N, Ix>>, Vec<Edge<E, Ix>>)
[src]
Convert the graph into a vector of Nodes and a vector of Edges
fn first_edge(&self, a: NodeIndex<Ix>, dir: Direction) -> Option<EdgeIndex<Ix>>
[src]
Accessor for data structure internals: the first edge in the given direction.
fn next_edge(&self, e: EdgeIndex<Ix>, dir: Direction) -> Option<EdgeIndex<Ix>>
[src]
Accessor for data structure internals: the next edge for the given direction.
fn index_twice_mut<T, U>(
&mut self,
i: T,
j: U
) -> (&mut <Graph<N, E, Ty, Ix> as Index<T>>::Output, &mut <Graph<N, E, Ty, Ix> as Index<U>>::Output) where
T: GraphIndex,
U: GraphIndex,
Graph<N, E, Ty, Ix>: IndexMut<T>,
Graph<N, E, Ty, Ix>: IndexMut<U>,
[src]
&mut self,
i: T,
j: U
) -> (&mut <Graph<N, E, Ty, Ix> as Index<T>>::Output, &mut <Graph<N, E, Ty, Ix> as Index<U>>::Output) where
T: GraphIndex,
U: GraphIndex,
Graph<N, E, Ty, Ix>: IndexMut<T>,
Graph<N, E, Ty, Ix>: IndexMut<U>,
Index the Graph
by two indices, any combination of
node or edge indices is fine.
Panics if the indices are equal or if they are out of bounds.
use petgraph::{Graph, Incoming}; use petgraph::visit::Dfs; let mut gr = Graph::new(); let a = gr.add_node(0.); let b = gr.add_node(0.); let c = gr.add_node(0.); gr.add_edge(a, b, 3.); gr.add_edge(b, c, 2.); gr.add_edge(c, b, 1.); // walk the graph and sum incoming edges into the node weight let mut dfs = Dfs::new(&gr, a); while let Some(node) = dfs.next(&gr) { // use a walker -- a detached neighbors iterator let mut edges = gr.neighbors_directed(node, Incoming).detach(); while let Some(edge) = edges.next_edge(&gr) { let (nw, ew) = gr.index_twice_mut(node, edge); *nw += *ew; } } // check the result assert_eq!(gr[a], 0.); assert_eq!(gr[b], 4.); assert_eq!(gr[c], 2.);
fn reverse(&mut self)
[src]
Reverse the direction of all edges
fn clear(&mut self)
[src]
Remove all nodes and edges
fn clear_edges(&mut self)
[src]
Remove all edges
fn capacity(&self) -> (usize, usize)
[src]
Return the current node and edge capacity of the graph.
fn reserve_nodes(&mut self, additional: usize)
[src]
Reserves capacity for at least additional
more nodes to be inserted in
the graph. Graph may reserve more space to avoid frequent reallocations.
Panics if the new capacity overflows usize
.
fn reserve_edges(&mut self, additional: usize)
[src]
Reserves capacity for at least additional
more edges to be inserted in
the graph. Graph may reserve more space to avoid frequent reallocations.
Panics if the new capacity overflows usize
.
fn reserve_exact_nodes(&mut self, additional: usize)
[src]
Reserves the minimum capacity for exactly additional
more nodes to be
inserted in the graph. Does nothing if the capacity is already
sufficient.
Prefer reserve_nodes
if future insertions are expected.
Panics if the new capacity overflows usize
.
fn reserve_exact_edges(&mut self, additional: usize)
[src]
Reserves the minimum capacity for exactly additional
more edges to be
inserted in the graph.
Does nothing if the capacity is already sufficient.
Prefer reserve_edges
if future insertions are expected.
Panics if the new capacity overflows usize
.
fn shrink_to_fit_nodes(&mut self)
[src]
Shrinks the capacity of the underlying nodes collection as much as possible.
fn shrink_to_fit_edges(&mut self)
[src]
Shrinks the capacity of the underlying edges collection as much as possible.
fn shrink_to_fit(&mut self)
[src]
Shrinks the capacity of the graph as much as possible.
fn retain_nodes<F>(&mut self, visit: F) where
F: FnMut(Frozen<Graph<N, E, Ty, Ix>>, NodeIndex<Ix>) -> bool,
[src]
F: FnMut(Frozen<Graph<N, E, Ty, Ix>>, NodeIndex<Ix>) -> bool,
Keep all nodes that return true
from the visit
closure,
remove the others.
visit
is provided a proxy reference to the graph, so that
the graph can be walked and associated data modified.
The order nodes are visited is not specified.
fn retain_edges<F>(&mut self, visit: F) where
F: FnMut(Frozen<Graph<N, E, Ty, Ix>>, EdgeIndex<Ix>) -> bool,
[src]
F: FnMut(Frozen<Graph<N, E, Ty, Ix>>, EdgeIndex<Ix>) -> bool,
Keep all edges that return true
from the visit
closure,
remove the others.
visit
is provided a proxy reference to the graph, so that
the graph can be walked and associated data modified.
The order edges are visited is not specified.
fn extend_with_edges<I>(&mut self, iterable: I) where
I: IntoIterator,
N: Default,
<I as IntoIterator>::Item: IntoWeightedEdge<E>,
<<I as IntoIterator>::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
[src]
I: IntoIterator,
N: Default,
<I as IntoIterator>::Item: IntoWeightedEdge<E>,
<<I as IntoIterator>::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
Extend the graph from an iterable of edges.
Node weights N
are set to default values.
Edge weights E
may either be specified in the list,
or they are filled with default values.
Nodes are inserted automatically to match the edges.
fn map<'a, F, G, N2, E2>(
&'a self,
node_map: F,
edge_map: G
) -> Graph<N2, E2, Ty, Ix> where
F: FnMut(NodeIndex<Ix>, &'a N) -> N2,
G: FnMut(EdgeIndex<Ix>, &'a E) -> E2,
[src]
&'a self,
node_map: F,
edge_map: G
) -> Graph<N2, E2, Ty, Ix> where
F: FnMut(NodeIndex<Ix>, &'a N) -> N2,
G: FnMut(EdgeIndex<Ix>, &'a E) -> E2,
Create a new Graph
by mapping node and
edge weights to new values.
The resulting graph has the same structure and the same
graph indices as self
.
fn filter_map<'a, F, G, N2, E2>(
&'a self,
node_map: F,
edge_map: G
) -> Graph<N2, E2, Ty, Ix> where
F: FnMut(NodeIndex<Ix>, &'a N) -> Option<N2>,
G: FnMut(EdgeIndex<Ix>, &'a E) -> Option<E2>,
[src]
&'a self,
node_map: F,
edge_map: G
) -> Graph<N2, E2, Ty, Ix> where
F: FnMut(NodeIndex<Ix>, &'a N) -> Option<N2>,
G: FnMut(EdgeIndex<Ix>, &'a E) -> Option<E2>,
Create a new Graph
by mapping nodes and edges.
A node or edge may be mapped to None
to exclude it from
the resulting graph.
Nodes are mapped first with the node_map
closure, then
edge_map
is called for the edges that have not had any endpoint
removed.
The resulting graph has the structure of a subgraph of the original graph.
If no nodes are removed, the resulting graph has compatible node
indices; if neither nodes nor edges are removed, the result has
the same graph indices as self
.
fn into_edge_type<NewTy>(self) -> Graph<N, E, NewTy, Ix> where
NewTy: EdgeType,
[src]
NewTy: EdgeType,
Convert the graph into either undirected or directed. No edge adjustments are done, so you may want to go over the result to remove or add edges.
Computes in O(1) time.
Trait Implementations
impl<A: Debug + Scalar> Debug for Graph<A>
[src]
impl<A: Scalar> From<Graph<Node<A>, ()>> for Graph<A>
[src]
impl<A: Scalar> Deref for Graph<A>
[src]
type Target = Graph<Node<A>, ()>
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
Dereferences the value.