Struct PermutedGraph 

pub struct PermutedGraph<'a, G: SequentialGraph, P: SliceByValue<Value = usize> + ?Sized> {
    pub graph: &'a G,
    pub perm: &'a P,
}

A wrapper applying a permutation to the iterators of an underlying graph.

Note that nodes are simply remapped: thus, neither the iterator on the graph nor the successors are sorted.

Fields

graph: &'a G

The underlying graph.

perm: &'a P

The permutation to apply: node i of the permuted graph corresponds to node perm[i] of the underlying graph.

Trait Implementations

impl<'a, G: Clone + SequentialGraph, P: Clone + SliceByValue<Value = usize> + ?Sized> Clone for PermutedGraph<'a, G, P>

fn clone(&self) -> PermutedGraph<'a, G, P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, G: Debug + SequentialGraph, P: Debug + SliceByValue<Value = usize> + ?Sized> Debug for PermutedGraph<'a, G, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'b, G: SequentialGraph, P: SliceByValue<Value = usize>> IntoLender for &'b PermutedGraph<'a, G, P>

type Lender = <PermutedGraph<'a, G, P> as SequentialLabeling>::Lender<'b>

The lender type that this type converts into.

fn into_lender(self) -> Self::Lender

Converts this type into a Lender.

impl<G: SequentialGraph, P: SliceByValue<Value = usize>> SequentialLabeling for PermutedGraph<'_, G, P>

type Label = usize

type Lender<'b> = NodeLabels<'b, <G as SequentialLabeling>::Lender<'b>, P> where Self: 'b

The type of Lender over the successors of a node returned by iter.

fn num_nodes(&self) -> usize

Returns the number of nodes in the graph.

fn num_arcs_hint(&self) -> Option<u64>

Returns the number of arcs in the graph, if available.

fn iter_from(&self, from: usize) -> Self::Lender<'_>

Returns an iterator over the labeling starting at from (included).

fn iter(&self) -> Self::Lender<'_>

Returns an iterator over the labeling.

fn build_dcf(&self) -> DCF

Builds the degree cumulative function for this labeling.

fn par_node_apply<A: Default + Send, F: Fn(Range<usize>) -> A + Sync, R: Fn(A, A) -> A + Sync>( &self, func: F, fold: R, granularity: Granularity, pl: &mut impl ConcurrentProgressLog, ) -> A

Applies func to each chunk of nodes of size node_granularity in parallel, and folds the results using fold.

fn par_apply<F: Fn(Range<usize>) -> A + Sync, A: Default + Send, R: Fn(A, A) -> A + Sync, D: for<'a> Succ<Input = usize, Output<'a> = usize>>( &self, func: F, fold: R, granularity: Granularity, deg_cumul: &D, pl: &mut impl ConcurrentProgressLog, ) -> A

Applies func to each chunk of nodes containing approximately arc_granularity arcs in parallel and folds the results using fold.

impl<'b, G: SequentialGraph + SplitLabeling, P: SliceByValue<Value = usize> + Send + Sync + Clone> SplitLabeling for PermutedGraph<'b, G, P>

where for<'a> <G as SequentialLabeling>::Lender<'a>: Clone + ExactSizeLender + Send + Sync,

type SplitLender<'a> = Take<<PermutedGraph<'b, G, P> as SequentialLabeling>::Lender<'a>> where Self: 'a

type IntoIterator<'a> = Iter<<PermutedGraph<'b, G, P> as SequentialLabeling>::Lender<'a>> where Self: 'a

fn split_iter(&self, how_many: usize) -> Self::IntoIterator<'_>

impl<G: SequentialGraph, P: SliceByValue<Value = usize>> SequentialGraph for PermutedGraph<'_, G, P>