Loading...
Searching...
No Matches
List of all members
Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T > Class Template Reference

Abstract simplex used in Skeleton blockers data-structure. More...

#include <include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h>

Public Member Functions

Constructors / Destructors / Initialization
void clear ()
 
 Skeleton_blocker_simplex (std::initializer_list< T > &list)
 
template<typename ... Args>
 Skeleton_blocker_simplex (Args ... args)
 
template<typename ... Args>
void add_vertices (T v, Args ... args)
 
void add_vertices (T v)
 
void add_vertices ()
 
 Skeleton_blocker_simplex (std::string token)
 
Simplex manipulation
void add_vertex (T v)
 
void remove_vertex (T v)
 
void intersection (const Skeleton_blocker_simplex &a)
 
void difference (const Skeleton_blocker_simplex &a)
 
void union_vertices (const Skeleton_blocker_simplex &a)
 
std::set< T >::const_iterator begin () const
 
std::set< T >::const_iterator end () const
 
std::set< T >::const_reverse_iterator rbegin () const
 
std::set< T >::const_reverse_iterator rend () const
 
std::set< T >::iterator begin ()
 
std::set< T >::iterator end ()
 

Queries

int dimension () const
 
bool empty () const
 
T first_vertex () const
 
T last_vertex () const
 
bool contains (const Skeleton_blocker_simplex &a) const
 
bool contains_difference (const Skeleton_blocker_simplex &a, const Skeleton_blocker_simplex &b) const
 
bool contains_difference (const Skeleton_blocker_simplex &a, T x) const
 
bool contains_difference (const Skeleton_blocker_simplex &a, T x, T y) const
 
bool contains (T v) const
 
bool disjoint (const Skeleton_blocker_simplex &a) const
 
bool operator== (const Skeleton_blocker_simplex &other) const
 
bool operator!= (const Skeleton_blocker_simplex &other) const
 
bool operator< (const Skeleton_blocker_simplex &other) const
 
std::ostream & operator<< (std::ostream &o, const Skeleton_blocker_simplex &sigma)
 

Detailed Description

template<typename T>
class Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >

Abstract simplex used in Skeleton blockers data-structure.

An abstract simplex is represented as an ordered set of T elements, each element representing a vertex.

The element representing a vertex can be SkeletonBlockerDS::Vertex_handle or SkeletonBlockerDS::Root_vertex_handle.

Constructor & Destructor Documentation

◆ Skeleton_blocker_simplex()

template<typename T >
Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::Skeleton_blocker_simplex ( std::string  token)
inlineexplicit

Initialize a simplex with a string such as {0,1,2}

Member Function Documentation

◆ add_vertex()

template<typename T >
void Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::add_vertex ( T  v)
inline

Add the vertex v to the simplex: Note that adding two times the same vertex is the same that adding it once.

◆ contains()

template<typename T >
bool Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::contains ( const Skeleton_blocker_simplex< T > &  a) const
inline
Returns
true iff the simplex contains the simplex a.

◆ contains_difference() [1/3]

template<typename T >
bool Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::contains_difference ( const Skeleton_blocker_simplex< T > &  a,
const Skeleton_blocker_simplex< T > &  b 
) const
inline
Returns
true iff the simplex contains the difference \( a \setminus b \).

◆ contains_difference() [2/3]

template<typename T >
bool Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::contains_difference ( const Skeleton_blocker_simplex< T > &  a,
T  x 
) const
inline
Returns
true iff the simplex contains the difference \( a \setminus \{ x \} \).

◆ contains_difference() [3/3]

template<typename T >
bool Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::contains_difference ( const Skeleton_blocker_simplex< T > &  a,
T  x,
T  y 
) const
inline
Returns
true iff the simplex contains the difference \( a \setminus \{ x,y \} \).

◆ difference()

template<typename T >
void Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::difference ( const Skeleton_blocker_simplex< T > &  a)
inline

Subtracts a from the simplex.

◆ dimension()

template<typename T >
int Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::dimension ( ) const
inline

Returns the dimension of the simplex.

◆ first_vertex()

template<typename T >
T Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::first_vertex ( ) const
inline

Returns the first and smallest vertex of the simplex.

Be careful : assumes the simplex is non-empty.

◆ intersection()

template<typename T >
void Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::intersection ( const Skeleton_blocker_simplex< T > &  a)
inline

Intersects the simplex with the simplex a.

◆ last_vertex()

template<typename T >
T Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::last_vertex ( ) const
inline

Returns the last and greatest vertex of the simplex.

Be careful : assumes the simplex is non-empty.

◆ remove_vertex()

template<typename T >
void Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::remove_vertex ( T  v)
inline

Remove the vertex v from the simplex:

◆ union_vertices()

template<typename T >
void Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T >::union_vertices ( const Skeleton_blocker_simplex< T > &  a)
inline

Add vertices of a to the simplex.

The documentation for this class was generated from the following file: