Struct Complete 

pub struct Complete<K>
where
    K: CompleteEdgeKind,
{ /* private fields */ }

Implementations

impl<K> Complete<K>

where K: CompleteEdgeKind,

pub fn new(n: u32) -> Complete<K>

Trait Implementations

impl<K> Adjacency for Complete<K>

where K: CompleteEdgeKind,

fn out_neighbors( &self, v: u32, ) -> <Complete<K> as VertexTypes<'_, Complete<K>>>::OutNeighborIter

fn out_degree(&self, v: <Complete<K> as WithVertex>::Vertex) -> usize

impl<K> Choose for Complete<K>

where K: CompleteEdgeKind,

fn choose_vertex<R>( &self, rng: R, ) -> Option<<Complete<K> as WithVertex>::Vertex>

where R: Rng,

Returns a random vertex of this graph or None if the graph has no vertices.

fn choose_out_neighbor<R>( &self, v: <Complete<K> as WithVertex>::Vertex, rng: R, ) -> Option<<Complete<K> as WithVertex>::Vertex>

where R: Rng,

Returns a random neighbor vertex of v or None if v has no neighbors.

fn choose_edge<R>(&self, rng: R) -> Option<<Complete<K> as WithEdge>::Edge>

where R: Rng,

Returns a random edge of this graph or None if the graph has no edges.

fn choose_out_edge<R>( &self, v: <Complete<K> as WithVertex>::Vertex, rng: R, ) -> Option<<Complete<K> as WithEdge>::Edge>

where R: Rng,

Returns a random out edge of v or None if v has no out edges.

fn choose_vertex_iter<R>(&self, rng: R) -> ChooseVertexIter<'_, Self, R>

where R: Rng,

Returns an iterator that repeatedly calls choose_vertex.

fn choose_out_neighbor_iter<R>( &self, v: Self::Vertex, rng: R, ) -> ChooseOutNeighborIter<'_, Self, R>

where R: Rng,

Returns an iterator that repeatedly calls choose_out_neighbor(v).

fn choose_edge_iter<R>(&self, rng: R) -> ChooseEdgeIter<'_, Self, R>

where R: Rng,

Returns an iterator that repeatedly calls choose_edge.

fn choose_out_edge_iter<R>( &self, v: Self::Vertex, rng: R, ) -> ChooseOutEdgeIter<'_, Self, R>

where R: Rng,

Returns an iterator that repeatedly calls choose_out_edge(v).

fn random_walk<R>(&self, rng: R) -> RandomWalk<'_, Self, R>

where R: Rng,

Returns a iterator that produces a sequence of random edges that forms a walk, that is, the target vertex of the previous edge is the source vertex of the next edge.

impl<K> Clone for Complete<K>

where K: Clone + CompleteEdgeKind,

fn clone(&self) -> Complete<K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K> Debug for Complete<K>

where K: Debug + CompleteEdgeKind,

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

Formats the value using the given formatter.

impl<K> EdgeList for Complete<K>

where K: CompleteEdgeKind,

fn edges(&self) -> <Complete<K> as EdgeTypes<'_, Complete<K>>>::EdgeIter

fn num_edges(&self) -> usize

fn get_edge_by_ends( &self, u: <Complete<K> as WithVertex>::Vertex, v: <Complete<K> as WithVertex>::Vertex, ) -> Option<<Complete<K> as WithEdge>::Edge>

fn edges_ends(&self) -> EdgesEnds<'_, Self, Self::EdgeIter>

fn edges_with_ends(&self) -> EdgesWithEnds<'_, Self, Self::EdgeIter>

fn edge_by_ends(&self, u: Self::Vertex, v: Self::Vertex) -> Self::Edge

impl<'a, K> EdgeTypes<'a, Complete<K>> for Complete<K>

where K: CompleteEdgeKind,

type EdgeIter = Map<Range<usize>, fn(usize) -> <K as CompleteEdgeKind>::Edge>

type OutEdgeIter = COutEdgeIter<<Complete<K> as WithEdge>::Edge>

impl<K> Incidence for Complete<K>

where K: CompleteEdgeKind,

fn out_edges( &self, v: <Complete<K> as WithVertex>::Vertex, ) -> <Complete<K> as EdgeTypes<'_, Complete<K>>>::OutEdgeIter

fn out_edges_ends( &self, v: Self::Vertex, ) -> EdgesEnds<'_, Self, Self::OutEdgeIter>

fn out_edges_with_ends( &self, v: Self::Vertex, ) -> EdgesWithEnds<'_, Self, Self::OutEdgeIter>

impl<K> PartialEq for Complete<K>

where K: PartialEq + CompleteEdgeKind,

fn eq(&self, other: &Complete<K>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K> VertexList for Complete<K>

where K: CompleteEdgeKind,

fn num_vertices(&self) -> usize

fn vertices(&self) -> <Complete<K> as VertexTypes<'_, Complete<K>>>::VertexIter

impl<'a, K> VertexTypes<'a, Complete<K>> for Complete<K>

where K: CompleteEdgeKind,

type VertexIter = Range<<Complete<K> as WithVertex>::Vertex>

type OutNeighborIter = COutNeighborIter

impl<K> WithEdge for Complete<K>

where K: CompleteEdgeKind,

type Kind = K

type Edge = <K as CompleteEdgeKind>::Edge

type OptionEdge = Optioned<<K as CompleteEdgeKind>::Edge, MaxNone<<K as CompleteEdgeKind>::Edge>>

fn source( &self, e: <Complete<K> as WithEdge>::Edge, ) -> <Complete<K> as WithVertex>::Vertex

fn target( &self, e: <Complete<K> as WithEdge>::Edge, ) -> <Complete<K> as WithVertex>::Vertex

fn end_vertices( &self, e: <Complete<K> as WithEdge>::Edge, ) -> (<Complete<K> as WithVertex>::Vertex, <Complete<K> as WithVertex>::Vertex)

fn orientation(&self, _e: <Complete<K> as WithEdge>::Edge) -> Orientation

fn reverse( &self, e: <Complete<K> as WithEdge>::Edge, ) -> <Complete<K> as WithEdge>::Edge

fn get_reverse( &self, e: <Complete<K> as WithEdge>::Edge, ) -> Option<<Complete<K> as WithEdge>::Edge>

fn ends<'a, I, O>(&'a self, item: I) -> O

where I: Ends<'a, Self, O>,

fn with_ends<I>( &self, iter: I, ) -> EdgesWithEnds<'_, Self, <I as IntoIterator>::IntoIter>

where I: IntoIterator, <I as IntoIterator>::Item: IntoOwned<Self::Edge>,

fn opposite(&self, u: Self::Vertex, e: Self::Edge) -> Self::Vertex

fn is_incident(&self, v: Self::Vertex, e: Self::Edge) -> bool

fn edge_none() -> Self::OptionEdge

fn edge_some(e: Self::Edge) -> Self::OptionEdge

fn edge_prop<P, T>(&self, value: T) -> P

where P: EdgePropMutNew<Self, T>, T: Clone,

fn edge_prop_from_fn<P, F, T>(&self, fun: F) -> P

where Self: EdgeList, P: EdgePropMutNew<Self, T>, F: FnMut(Self::Edge) -> T, T: Default + Clone,

impl<K> WithEdgeIndexProp for Complete<K>

where K: CompleteEdgeKind,

type EdgeIndexProp = CEdgeIndexProp<<K as CompleteEdgeKind>::Edge>

fn edge_index(&self) -> CEdgeIndexProp<<K as CompleteEdgeKind>::Edge>

Creates an edge index map.

impl<T, K> WithEdgeProp<T> for Complete<K>

where K: CompleteEdgeKind, Complete<K>: WithEdgeIndexProp,

type EdgeProp = ArrayProp<<Complete<K> as WithEdgeIndexProp>::EdgeIndexProp, Vec<T>>

fn default_edge_prop(&self, value: T) -> Self::EdgeProp

where T: Clone,

Creates a new default edge property where the initial value associated with each edge is value.

fn default_edge_prop_from_fn<P, F>(&self, fun: F) -> P

where Self: EdgeList, P: EdgePropMutNew<Self, T>, F: FnMut(Self::Edge) -> T, T: Default + Clone,

Creates a new default edge property where the initial value associated with each edge e is produced by fun(e).

impl<K> WithVertex for Complete<K>

where K: CompleteEdgeKind,

type Vertex = u32

type OptionVertex = Optioned<u32, MaxNone<u32>>

fn vertex_none() -> Self::OptionVertex

fn vertex_some(v: Self::Vertex) -> Self::OptionVertex

fn vertex_prop<P, T>(&self, value: T) -> P

where P: VertexPropMutNew<Self, T>, T: Clone,

fn vertex_prop_from_fn<P, T, F>(&self, fun: F) -> P

where Self: VertexList, P: VertexPropMutNew<Self, T>, F: FnMut(Self::Vertex) -> T, T: Default + Clone,

impl<K> WithVertexIndexProp for Complete<K>

where K: CompleteEdgeKind,

type VertexIndexProp = CVertexIndexProp

fn vertex_index(&self) -> CVertexIndexProp

Creates an vertex index map.

impl<T, K> WithVertexProp<T> for Complete<K>

where K: CompleteEdgeKind,

type VertexProp = ArrayProp<<Complete<K> as WithVertexIndexProp>::VertexIndexProp, Vec<T>>

The vertex property type.

fn default_vertex_prop(&self, value: T) -> Self::VertexProp

where T: Clone,

Creates a new default vertex property where the initial value associated with each vertex is value.

fn default_vertex_prop_from_fn<P, F>(&self, fun: F) -> P

where Self: VertexList, P: VertexPropMutNew<Self, T>, F: FnMut(Self::Vertex) -> T, T: Default + Clone,

Creates a new default vertex property where the initial value associated with each vertex v is produced by fun(v).

impl<K> BasicEdgeProps for Complete<K>

where K: CompleteEdgeKind,

impl<K> BasicProps for Complete<K>

where K: CompleteEdgeKind,

impl<K> BasicVertexProps for Complete<K>

where K: CompleteEdgeKind,

impl<K> Copy for Complete<K>

where K: Copy + CompleteEdgeKind,

impl<K> Eq for Complete<K>

where K: Eq + CompleteEdgeKind,

impl<K> StructuralPartialEq for Complete<K>

where K: CompleteEdgeKind,