Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

Gudhi::witness_complex::Active_witness< Id_distance_pair, INS_range > | Class representing a list of nearest neighbors to a given witness
Gudhi::witness_complex::Active_witness_iterator< Active_witness, Id_distance_pair, INS_iterator > | Iterator in the nearest landmark list
Gudhi::witness_complex::Active_witness_iterator< ActiveWitness, Id_distance_pair, INS_iterator > |
Gudhi::alpha_complex::Alpha_complex< Kernel, Weighted > | Alpha complex data structure
Gudhi::alpha_complex::Alpha_complex_3d< Complexity, Weighted, Periodic > | Alpha complex data structure for 3d specific case
Gudhi::alpha_complex::Alpha_kernel_d< Kernel, Weighted > | Alpha complex kernel container
Gudhi::Persistence_representations::arc_tan_of_persistence_of_point |
Gudhi::persistence_matrix::Base_matrix< Master_matrix > | A basic matrix structure allowing to easily manipulate and access entire columns and rows, but not individual entries

Gudhi::persistence_matrix::Base_matrix_with_column_compression< Master_matrix >

A base matrix (also see Base_matrix), but with column compression. That is, all identical columns in the matrix are compressed together as the same column. For matrices with a lot of redundant columns, this will save a lot of space. Also, any addition made onto a column will be performed at the same time on all other identical columns, which is an advantage for the cohomology algorithm for example

Gudhi::persistence_matrix::Base_pairing< Master_matrix > | Class managing the barcode for Boundary_matrix if the option was enabled
Gudhi::persistence_matrix::Base_swap< Master_matrix, Base_matrix > | Class managing the column and row swaps in Base_matrix and Boundary_matrix
Gudhi::cubical_complex::Bitmap_cubical_complex< T > | Cubical complex represented as a bitmap
Gudhi::cubical_complex::Bitmap_cubical_complex_base< T > | Cubical complex represented as a bitmap, class with basic implementation
Gudhi::cubical_complex::Bitmap_cubical_complex_periodic_boundary_conditions_base< T > | Cubical complex with periodic boundary conditions represented as a bitmap
Gudhi::skeleton_blocker::Blocker_iterator_around_vertex_internal< MapIteratorType, ReturnType > | Iterator through the blockers of a vertex
Gudhi::skeleton_blocker::Blocker_iterator_around_vertex_internal< typename std::multimap< Vertex_handle, Simplex * >::const_iterator, const Blocker_handle > |
Gudhi::skeleton_blocker::Blocker_iterator_around_vertex_internal< typename std::multimap< Vertex_handle, Simplex * >::iterator, Blocker_handle > |
Gudhi::skeleton_blocker::Blocker_iterator_internal< MapIteratorType, ReturnType > | Iterator through the blockers of a vertex
Gudhi::skeleton_blocker::Blocker_iterator_internal< typename std::multimap< Vertex_handle, Simplex * >::const_iterator, const Blocker_handle > |
Gudhi::skeleton_blocker::Blocker_iterator_internal< typename std::multimap< Vertex_handle, Simplex * >::iterator, Blocker_handle > |
Gudhi::persistence_matrix::Boundary_matrix< Master_matrix > | Matrix structure to store the ordered boundary matrix \( R \) of a filtered complex in order to compute its persistent homology. Provides an access to its columns and rows as well as the possibility to remove the last cells of the filtration while maintaining a valid barcode
Gudhi::persistence_matrix::Boundary_matrix< Matrix< PersistenceMatrixOptions > > |
Gudhi::coxeter_triangulation::Cartesian_product< Functions > | Constructs the function the zero-set of which is the Cartesian product of the zero-sets of some given functions
Gudhi::cech_complex::Cech_complex< Kernel, SimplicialComplexForCechComplex > | Cech complex class
Gudhi::coxeter_triangulation::Cell_complex< Out_simplex_map_ > | A class that constructs the cell complex from the output provided by the class Gudhi::coxeter_triangulation::Manifold_tracing
Gudhi::persistence_matrix::Chain_column_extra_properties< Master_matrix > | Class managing the pivot and partitioning of columns in Chain_matrix
Gudhi::persistence_matrix::PersistenceMatrixColumn | Concept of the column classes used by the Matrix class. The classes the columns inherit from are either real or dummy classes, see Row_access_option, Column_dimension_option, Chain_column_option. If used with column compression, the column type has to have its std::hash method

Gudhi::persistence_matrix::Chain_matrix< Master_matrix >

Matrix structure storing a compatible base of a filtered chain complex. See [zigzag]. The base is constructed from the boundaries of the cells in the complex. Allows the persistent homology to be computed, as well as representative cycles. Supports vineyards (see [vineyards]) and the removal of maximal cells while maintaining a valid barcode. Provides an access to its columns and rows

Gudhi::persistence_matrix::Chain_matrix< Matrix< PersistenceMatrixOptions > > |
Gudhi::persistence_matrix::Chain_pairing< Master_matrix > | Class managing the barcode for Chain_matrix if the option was enabled
Gudhi::persistence_matrix::Chain_barcode_swap< Master_matrix > | Class managing the barcode for Chain_vine_swap
Gudhi::persistence_matrix::Chain_representative_cycles< Master_matrix > | Class managing the representative cycles for Chain_matrix if the option was enabled
Gudhi::persistence_matrix::Chain_vine_swap< Master_matrix > | Class managing the vine swaps for Chain_matrix
CoefficientField | Concept describing the requirements for a class to represent a field of coefficients to compute persistent homology
Gudhi::persistent_cohomology::Field_Zp | Structure representing the coefficient field \(\mathbb{Z}/p\mathbb{Z}\)
Gudhi::persistent_cohomology::Multi_field | Structure representing coefficients in a set of finite fields simultaneously using the chinese remainder theorem
Gudhi::coxeter_triangulation::Coface_iterator< Permutahedral_representation > | Iterator over the k-cofaces of a simplex given by its permutahedral representation
Gudhi::coxeter_triangulation::Coface_iterator< Self > |
Gudhi::persistence_matrix::Base_matrix_with_column_compression< Master_matrix >::Column | Type for columns. Only one for each "column class" is explicitly constructed
Gudhi::persistence_matrix::Column_dimension_holder< Master_matrix > | Class managing the dimension access of a column
Gudhi::persistence_matrix::PersistenceMatrixColumn | Concept of the column classes used by the Matrix class. The classes the columns inherit from are either real or dummy classes, see Row_access_option, Column_dimension_option, Chain_column_option. If used with column compression, the column type has to have its std::hash method
Gudhi::coxeter_triangulation::Combination_iterator | Class that allows the user to generate combinations of k elements in a set of n elements. Based on the algorithm by Mifsud
Gudhi::coxeter_triangulation::Constant_function | A class that encodes a constant function from R^d to R^k. This class does not have any implicit manifold in correspondence
Gudhi::Persistence_representations::constant_scaling_function |
Gudhi::contraction::Contraction_visitor< EdgeProfile > | Interface for a visitor of the edge contraction process
Gudhi::contraction::Contraction_visitor< Profile > |
Gudhi::contraction::Contraction_visitor_remove_popable< Profile > | Visitor to remove popable blockers after an edge contraction
Gudhi::contraction::Cost_policy< EdgeProfile > | Policy to specify the cost of contracting an edge
Gudhi::contraction::Edge_length_cost< EdgeProfile > | Return a cost corresponding to the squared length of the edge
Gudhi::cover_complex::Cover_complex< Point > | Cover complex data structure
Default_options< col_type, is_z2_only, FieldOperators > | Default option structure for Matrix class. See the PersistenceMatrixOptions concept for a more detailed description of the fields. Produces a base matrix with no enabled option
Gudhi::persistence_matrix::Default_options< col_type, is_z2_only, FieldOperators > | Default option structure for Matrix class. See the PersistenceMatrixOptions concept for a more detailed description of the fields. Produces a base matrix with no enabled option
Gudhi::persistence_matrix::Default_options< column_type, true > |
Gudhi::zigzag_persistence::Zigzag_matrix_options< Options::column_type > |
Gudhi::zigzag_persistence::Zigzag_matrix_options< column_type > | Options for the internal matrix of Zigzag_persistence
Gudhi::persistence_matrix::Default_options< Column_types::INTRUSIVE_LIST, true > |
Gudhi::persistence_matrix::Zigzag_options< column_type > | Options used for the Zigzag persistence module
Gudhi::persistence_matrix::Default_options< Column_types::INTRUSIVE_LIST, true, persistence_fields::Zp_field_operators<> > |
Gudhi::persistence_matrix::Cohomology_persistence_options< column_type, is_z2_only, FieldOperators > | Options used by the cohomology module
Gudhi::persistence_matrix::Default_options< Column_types::INTRUSIVE_SET, true > |
Gudhi::persistence_matrix::Multi_persistence_options< column_type > | Options used by the Multipersistence module
Gudhi::persistence_matrix::Representative_cycles_options< col_type > | Options needed to use the representative cycles
Gudhi::zigzag_persistence::Default_zigzag_options | Default options for Zigzag_persistence
Gudhi::zigzag_persistence::Default_filtered_zigzag_options | Default options for Filtered_zigzag_persistence_with_storage and Filtered_zigzag_persistence

Gudhi::persistence_diagram::DiagramPoint

Concept of point in a persistence diagram. std::get<0>(point) must return the birth of the corresponding component and std::get<1>(point) its death. Both should be convertible to double. A valid implementation of this concept is std::pair<double,double>. Death should be larger than birth, death can be std::numeric_limits<double>::infinity() for components which stay alive

Gudhi::Persistence_representations::distance_from_diagonal_scaling |
Gudhi::persistence_matrix::Dummy_base_pairing | Empty structure. Inherited instead of Base_pairing, when the computation of the barcode was not enabled or if the pairing is already managed by the vine update classes
Gudhi::persistence_matrix::Dummy_base_swap | Empty structure. Inherited instead of Base_swap, when the column and row swaps are not enabled
Gudhi::persistence_matrix::Dummy_chain_pairing | Empty structure. Inherited instead of Chain_pairing, when the computation of the barcode was not enabled or if the pairing is already managed by the vine update classes
Gudhi::persistence_matrix::Dummy_chain_properties | Empty structure. Inherited instead of Chain_column_extra_properties, when the columns are not meant for chain matrices
Gudhi::persistence_matrix::Dummy_chain_representative_cycles | Empty structure. Inherited instead of Chain_representative_cycles, when the computation of the representative cycles were not enabled
Gudhi::persistence_matrix::Dummy_chain_vine_pairing | Empty structure. Inherited instead of Chain_barcode_swap, when the barcode is not stored
Gudhi::persistence_matrix::Dummy_chain_vine_swap | Empty structure. Inherited instead of Chain_vine_swap, when vine swaps are not enabled
Gudhi::persistence_matrix::Dummy_dimension_holder | Empty structure. Inherited instead of Column_dimension_holder, when the columns are not storing a dimension
Gudhi::persistence_matrix::Dummy_entry_column_index_mixin | Empty structure. Inherited instead of Entry_column_index, when the row access is disabled
Gudhi::persistence_matrix::Dummy_entry_field_element_mixin | Empty structure. Inherited instead of Entry_field_element, when PersistenceMatrixOptions::is_z2 is true
Gudhi::persistence_matrix::Dummy_matrix_dimension_holder | Empty structure. Inherited instead of Matrix_max_dimension_holder or Matrix_all_dimension_holder, when the maximal dimension of a matrix is not stored
Gudhi::persistence_matrix::Dummy_matrix_row_access | Empty structure. Inherited instead of Matrix_row_access, when the the row access is not enabled
Gudhi::persistence_matrix::Dummy_row_access | Empty structure. Inherited instead of Row_access, if the row access is not enabled
Gudhi::persistence_matrix::Dummy_ru_pairing | Empty structure. Inherited instead of RU_pairing, when the computation of the barcode was not enabled or if the pairing is already managed by the vine update classes
Gudhi::persistence_matrix::Dummy_ru_representative_cycles | Empty structure. Inherited instead of RU_representative_cycles, when the computation of the representative cycles were not enabled
Gudhi::persistence_matrix::Dummy_ru_vine_pairing | Empty structure. Inherited instead of RU_pairing, when the barcode is not stored
Gudhi::persistence_matrix::Dummy_ru_vine_swap | Empty structure. Inherited instead of RU_vine_swap, when vine swaps are not enabled
Gudhi::skeleton_blocker::Edge_iterator< SkeletonBlockerComplex > | Iterator on the edges of a simplicial complex
Gudhi::skeleton_blocker::Edge_iterator< Skeleton_blocker_complex > |
Gudhi::coxeter_triangulation::Embed_in_Rd< Function_ > | Embedding of an implicit manifold in a higher dimension
Gudhi::persistence_matrix::Entry< Master_matrix > | Matrix entry class. Stores by default only the row index it belongs to, but can also store its column index when the row access is enabled, as well as its value when they are different from only 0 and 1. Zero-valued entries are never made explicit in the matrix
Gudhi::persistence_matrix::Entry< Matrix< PersistenceMatrixOptions > > |
Gudhi::persistence_matrix::Entry_column_index< Index > | Class managing the column index access of an entry
Gudhi::persistence_matrix::Entry_field_element< Field_element > | Class managing the value access of an entry
Gudhi::Euclidean_distance | Compute the Euclidean distance between two Points given by a range of coordinates. The points are assumed to have the same dimension
Extended_simplex_type | Extended simplex type data structure for representing the type of simplices in an extended filtration
Gudhi::coxeter_triangulation::Face_iterator< Permutahedral_representation > | Iterator over the k-faces of a simplex given by its permutahedral representation
Gudhi::coxeter_triangulation::Face_iterator< Self > |
Gudhi::persistence_matrix::FieldOperators | Concept of the field operator classes needed for the class Matrix
Gudhi::zigzag_persistence::Filtered_zigzag_persistence< FilteredZigzagOptions > | Class computing the zigzag persistent homology of a zigzag filtration. Algorithm based on [zigzag]

Gudhi::zigzag_persistence::Filtered_zigzag_persistence_with_storage< FilteredZigzagOptions >

Class computing the zigzag persistent homology of a zigzag filtration. Algorithm based on [zigzag]. Even though the insertions and removals are given in a "stream-like" way, the barcode and other values are stored during the whole process and not removed. It is therefore suited for smaller filtrations where the clean ups produce a higher overhead than the memory consumption

FilteredComplex | The concept FilteredComplex describes the requirements for a type to implement a filtered cell complex, from which one can compute persistent homology via a model of the concept PersistentHomology
Gudhi::zigzag_persistence::FilteredZigzagOptions | List of options used for the filtered zigzag persistence computation
FiltrationValue | Value type for a filtration function on a cell complex
Gudhi::tangential_complex::Tangential_complex< Kernel_, DimensionTag, Concurrency_tag, Triangulation_ >::Fix_inconsistencies_info | Type returned by Tangential_complex::fix_inconsistencies_using_perturbation
Gudhi::coxeter_triangulation::Freudenthal_triangulation< Permutahedral_representation_ > | A class that stores any affine transformation of the Freudenthal-Kuhn triangulation
Gudhi::coxeter_triangulation::Coxeter_triangulation< Permutahedral_representation_ > | A class that stores Coxeter triangulation of type \(\tilde{A}_d\). This triangulation has the greatest simplex quality out of all linear transformations of the Freudenthal-Kuhn triangulation
Gudhi::coxeter_triangulation::Function_affine_plane_in_Rd | A class for the function that defines an m-dimensional implicit affine plane embedded in d-dimensional Euclidean space
Gudhi::coxeter_triangulation::Function_chair_in_R3 | A class that encodes the function, the zero-set of which is a so-called "chair" surface embedded in R^3
Gudhi::coxeter_triangulation::Function_iron_in_R3 | A class that encodes the function, the zero-set of which is a surface embedded in R^3 that ressembles an iron
Gudhi::coxeter_triangulation::Function_lemniscate_revolution_in_R3 | A class that encodes the function, the zero-set of which is a surface of revolution around the x axis based on the lemniscate of Bernoulli embedded in R^3
Gudhi::coxeter_triangulation::Function_moment_curve_in_Rd | A class for the function that defines an implicit moment curve in the d-dimensional Euclidean space
Gudhi::coxeter_triangulation::Function_Sm_in_Rd | A class for the function that defines an m-dimensional implicit sphere embedded in the d-dimensional Euclidean space
Gudhi::coxeter_triangulation::Function_torus_in_R3 | A class that encodes the function, the zero-set of which is a torus surface embedded in R^3
Gudhi::coxeter_triangulation::Function_whitney_umbrella_in_R3 | A class that encodes the function, the zero-set of which is the Whitney umbrella surface embedded in R^3
Gudhi::coxeter_triangulation::FunctionForImplicitManifold | The concept FunctionForImplicitManifold describes the requirements for a type to implement an implicit function class used for example in Manifold_tracing
Gudhi::skeleton_blocker::SkeletonBlockerDS::Graph_edge | The type of edges that are stored the boost graph. An Edge must be Default Constructible and Equality Comparable
Gudhi::skeleton_blocker::SkeletonBlockerGeometricDS< GeometryTrait >::Graph_Edge | Edge that allows to access to an index. The indices of the edges are used to store heap information in the edge contraction algorithm
Gudhi::skeleton_blocker::SkeletonBlockerDS::Graph_vertex | The type of vertices that are stored the boost graph. A Vertex must be Default Constructible and Equality Comparable
Gudhi::skeleton_blocker::SkeletonBlockerGeometricDS< GeometryTrait >::Graph_vertex | Vertex that stores a point
std::hash< Gudhi::persistence_matrix::Entry< Master_matrix > > | Hash method for Gudhi::persistence_matrix::Entry
std::hash< Gudhi::persistence_matrix::Heap_column< Master_matrix > > | Hash method for Gudhi::persistence_matrix::Heap_column
std::hash< Gudhi::persistence_matrix::Intrusive_list_column< Master_matrix > > | Hash method for Gudhi::persistence_matrix::Intrusive_list_column
std::hash< Gudhi::persistence_matrix::Intrusive_set_column< Master_matrix > > | Hash method for Gudhi::persistence_matrix::Intrusive_set_column
std::hash< Gudhi::persistence_matrix::List_column< Master_matrix > > | Hash method for Gudhi::persistence_matrix::List_column
std::hash< Gudhi::persistence_matrix::Naive_vector_column< Master_matrix, Support > > | Hash method for Gudhi::persistence_matrix::Naive_vector_column
std::hash< Gudhi::persistence_matrix::Set_column< Master_matrix > > | Hash method for Gudhi::persistence_matrix::Set_column
std::hash< Gudhi::persistence_matrix::Unordered_set_column< Master_matrix > > | Hash method for Gudhi::persistence_matrix::Unordered_set_column
std::hash< Gudhi::persistence_matrix::Vector_column< Master_matrix > > | Hash method for Gudhi::persistence_matrix::Vector_column
Gudhi::Hasse_diagram::Hasse_diagram_cell< Incidence_type_, Filtration_type_, Additional_information_ > | Data structure to store a cell in a Hasse diagram
Gudhi::persistence_matrix::Heap_column< Master_matrix > | Column class following the PersistenceMatrixColumn concept. Not compatible with row access
Gudhi::persistence_matrix::Heap_column< Matrix< PersistenceMatrixOptions > > |
Gudhi::Hooks_simplex_base_dummy | No hook when SimplexTreeOptions::link_nodes_by_label is false
Gudhi::Hooks_simplex_base_link_nodes | Data structure to put all simplex tree nodes with same label into a list
Gudhi::persistence_matrix::Id_to_index_overlay< Underlying_matrix, Master_matrix > | Overlay for non-basic matrices replacing all input and output MatIdx indices of the original methods with IDIdx indices
Gudhi::coxeter_triangulation::Implicit_manifold_intersection_oracle< Function_, Domain_function_ > | An oracle that supports the intersection query on an implicit manifold
IndexingTag | Concept describing an indexing scheme (see FilteredComplex) for applying continuous maps to a cell complex, and compute its persistent homology
Gudhi::linear_indexing_tag | Tag for a linear ordering of simplices
Gudhi::coxeter_triangulation::Integer_combination_iterator | Class that allows the user to generate combinations of k elements in a set of n elements. Based on the algorithm by Mifsud
Gudhi::coxeter_triangulation::IntersectionOracle | The concept IntersectionOracle describes the requirements for a type to implement an intersection oracle class used for example in Manifold_tracing
Gudhi::persistence_matrix::Intrusive_list_column< Master_matrix > | Column class following the PersistenceMatrixColumn concept
Gudhi::persistence_matrix::Intrusive_list_column< Matrix< PersistenceMatrixOptions > > |
Gudhi::persistence_matrix::Intrusive_set_column< Master_matrix > | Column class following the PersistenceMatrixColumn concept
Gudhi::persistence_matrix::Intrusive_set_column< Matrix< PersistenceMatrixOptions > > |
Gudhi::Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator< SimplexTree >::is_coface | Predicate to check whether an input SimplexTree::Node represents a coface of a simplex simp_, stored as a std::vector of SimplexTree::Vertex_handle sorted in decreasing Vertex_handle order
Gudhi::spatial_searching::Kd_tree_search< Search_traits, Point_range > | Spatial tree data structure to perform (approximate) nearest and furthest neighbor search
Gudhi::Lazy_toplex_map | Lazy toplex map data structure for representing unfiltered simplicial complexes
Gudhi::coxeter_triangulation::Linear_transformation< Function_ > | Transforms the zero-set of the function by a given linear transformation. The underlying function corresponds to f(M*x), where M is the transformation matrix
Gudhi::persistence_matrix::List_column< Master_matrix > | Column class following the PersistenceMatrixColumn concept
Gudhi::persistence_matrix::List_column< Matrix< PersistenceMatrixOptions > > |
Gudhi::coxeter_triangulation::Manifold_tracing< Triangulation_ > | A class that assembles methods for manifold tracing algorithm
Gudhi::persistence_matrix::Matrix< PersistenceMatrixOptions > | Data structure for matrices, and in particular thought for matrices representing filtered complexes in order to compute persistence and/or representative cycles
Gudhi::persistence_matrix::Matrix_all_dimension_holder< Dimension > | Class managing the maximal dimension of a cell represented in the inheriting matrix, when the option of cell removal is enabled
Gudhi::persistence_matrix::Matrix_max_dimension_holder< Dimension > | Class managing the maximal dimension of a cell represented in the inheriting matrix, when the option of cell removal is not enabled
Gudhi::persistence_matrix::Matrix_row_access< Row, Row_container, has_removable_rows, ID_index > | Class managing the row access for the inheriting matrix
Gudhi::coxeter_triangulation::Mesh_medit | Structure to store a mesh that can be output in Medit .mesh file format using the output_meshes_to_medit method
Gudhi::persistence_fields::Multi_field_element< minimum, maximum > | Class representing an element of a multi-field. The characteristics will corresponds to all prime numbers in the interval given as template
Gudhi::persistence_fields::Multi_field_element_with_small_characteristics< minimum, maximum, Unsigned_integer_type, class > | Class representing an element of a multi-field, such that the product of all characteristics fits into the given `Unsigned_integer_type` template argument. The characteristics will corresponds to all prime numbers in the interval given as other template arguments
Gudhi::persistence_fields::Multi_field_operators | Class defining operators for a multi-field with "consecutive" characteristic range
Gudhi::persistence_fields::Multi_field_operators_with_small_characteristics | Class defining operators for a multi-field with "consecutive" characteristic range, such that productOfAllCharacteristics ^ 2 fits into an unsigned int
Gudhi::persistence_matrix::Naive_vector_column< Master_matrix, Support > | Column class following the PersistenceMatrixColumn concept
Gudhi::persistence_matrix::Naive_vector_column< Master_matrix, boost::container::small_vector< typename Master_matrix::Matrix_entry *, 8 > > |
Gudhi::persistence_matrix::Naive_vector_column< Master_matrix, std::vector< typename Master_matrix::Matrix_entry * > > |
Gudhi::coxeter_triangulation::Negation< Function_ > | Constructs the "minus" function. The zero-set is the same, but the values at other points are the negative of their original value
Gudhi::Null_output_iterator |
Gudhi::tangential_complex::Tangential_complex< Kernel_, DimensionTag, Concurrency_tag, Triangulation_ >::Num_inconsistencies | Type returned by Tangential_complex::number_of_inconsistent_simplices
Gudhi::Off_reader | OFF file reader top class visitor
Gudhi::coxeter_triangulation::Ordered_set_partition | Class that represents an ordered set partition of a set {0,...,n-1} in k parts as a pair of an unordered set partition given in lexicographic order and a permutation of the parts
Gudhi::coxeter_triangulation::Ordered_set_partition_iterator | Class that allows the user to generate set partitions of a set {0,...,n-1} in k parts
Gudhi::coxeter_triangulation::Permutahedral_representation< Vertex_, Ordered_set_partition_ > | A class that stores the permutahedral representation of a simplex in a Coxeter triangulation or a Freudenthal-Kuhn triangulation
Gudhi::coxeter_triangulation::Permutation_iterator | Class that allows the user to generate permutations. Based on the optimization of the Heap's algorithm by Sedgewick
Gudhi::Persistence_representations::Persistence_heat_maps< Scalling_of_kernels > | A class implementing persistence heat maps
Gudhi::Persistence_representations::Persistence_heat_maps< constant_scaling_function > |
Gudhi::Persistence_representations::PSSK |
Gudhi::persistence_matrix::Persistence_interval< Dimension, Event_value > | Type for an interval in a persistent diagram or barcode. Stores the birth, death and dimension of the interval. It can be used as a tuple with get/std::get (birth, death and dimension in this order), std::tuple_element and std::tuple_size, as well as structured binding
Gudhi::Persistence_interval_common< Filtration_type, Coefficient_field > |
Gudhi::Persistence_representations::Persistence_intervals |
Gudhi::Persistence_representations::Persistence_landscape | A class implementing persistence landscapes data structures
Gudhi::Persistence_representations::Persistence_landscape_on_grid | A class implementing persistence landscapes by approximating them on a collection of grid points
Gudhi::persistence_diagram::PersistenceDiagram | Concept of persistence diagram. It is a range of DiagramPoint. std::begin(diagram) and std::end(diagram) must return corresponding iterators
Gudhi::persistence_matrix::PersistenceMatrixOptions | Concept of the template parameter for the class Matrix
PersistentHomology | Concept describing the requirements for a class to compute persistent homology
Gudhi::persistent_cohomology::Persistent_cohomology< Simplex_tree, Field_Zp > |
Gudhi::persistent_cohomology::Persistent_cohomology< Simplex_tree, Gudhi::persistent_cohomology::Field_Zp > |
Gudhi::persistent_cohomology::Persistent_cohomology< ST, Field_Zp > |
Gudhi::persistent_cohomology::Persistent_cohomology< Simplex_tree, Multi_field > |
Gudhi::persistent_cohomology::Persistent_cohomology< SimplexTree, Field_Zp > |
Gudhi::persistent_cohomology::Persistent_cohomology< FilteredComplex, CoefficientField > | Computes the persistent cohomology of a filtered complex
Gudhi::coxeter_triangulation::PL_approximation< Function_, Triangulation_ > | Constructs a piecewise-linear approximation of a function induced by an ambient triangulation
Gudhi::contraction::Placement_policy< EdgeProfile > | Policy to specify where the merged point had to be placed after an edge contraction
Gudhi::contraction::First_vertex_placement< EdgeProfile > | Places the contracted point onto the first point of the edge
Gudhi::Points_3D_off_reader< Point_3 > |
Gudhi::Points_3D_off_visitor_reader< Point_3 > | OFF file visitor implementation according to Off_reader in order to read points from an OFF file
Gudhi::Points_off_reader< Point_d > | OFF file reader implementation in order to read points from an OFF file
Gudhi::Points_off_visitor_reader< Point_d > | OFF file visitor implementation according to Off_reader in order to read points from an OFF file
Gudhi::persistence_matrix::Position_to_index_overlay< Underlying_matrix, Master_matrix > | Overlay for chain matrices replacing all input and output MatIdx indices of the original methods with PosIdx indices. The overlay is useless for boundary matrices as MatIdx == PosIdx for them
Gudhi::coxeter_triangulation::Query_result< Simplex_handle > | The result of a query by an oracle such as Implicit_manifold_intersection_oracle
Gudhi::Persistence_representations::Real_valued_topological_data | The concept Real_valued_topological_data describes the requirements for a type to implement a container that allows computations of its projections to R
Gudhi::rips_complex::Rips_complex< Filtration_value > | Rips complex data structure

Gudhi::skeleton_blocker::Skeleton_blocker_simple_traits::Root_vertex_handle

Global and local handle similar to boost subgraphs. Vertices are stored in a vector. For the root simplicial complex, the local and global descriptors are the same. For a subcomplex L and one of its vertices 'v', the local descriptor of 'v' is its position in the vertex vector of the subcomplex L whereas its global descriptor is the position of 'v' in the vertex vector of the root simplicial complex

Gudhi::skeleton_blocker::SkeletonBlockerDS::Root_vertex_handle | Root_vertex_handle and Vertex_handle are similar to global and local vertex descriptor used in boost subgraphs and allow to localize a vertex of a subcomplex on its parent root complex
Gudhi::persistence_matrix::Row_access< Master_matrix > | Class managing the row access for the columns
Gudhi::persistence_matrix::PersistenceMatrixColumn | Concept of the column classes used by the Matrix class. The classes the columns inherit from are either real or dummy classes, see Row_access_option, Column_dimension_option, Chain_column_option. If used with column compression, the column type has to have its std::hash method
Gudhi::persistence_matrix::Matrix< PersistenceMatrixOptions >::RowEntryComp | Compares two entries by their position in the row. They are assume to be in the same row
Gudhi::persistence_matrix::RU_matrix< Master_matrix > | Matrix structure to store the ordered boundary matrix \( R \cdot U \) of a filtered complex in order to compute its persistent homology, as well as representative cycles. Supports vineyards (see [vineyards]) and the removal of maximal cells while maintaining a valid barcode. Provides an access to its columns and rows
Gudhi::persistence_matrix::RU_matrix< Matrix< PersistenceMatrixOptions > > |
Gudhi::persistence_matrix::RU_pairing< Master_matrix > | Class managing the barcode for RU_matrix if the option was enabled
Gudhi::persistence_matrix::RU_representative_cycles< Master_matrix > | Class managing the representative cycles for RU_matrix if the option was enabled
Gudhi::persistence_matrix::RU_vine_swap< Master_matrix > | Class managing the vine swaps for RU_matrix
Gudhi::persistence_matrix::Set_column< Master_matrix > | Column class following the PersistenceMatrixColumn concept
Gudhi::persistence_matrix::Set_column< Matrix< PersistenceMatrixOptions > > |
Gudhi::coxeter_triangulation::Set_partition_iterator | Class that allows the user to generate set partitions of a set {0,...,n-1} in k parts

Gudhi::persistence_fields::Shared_multi_field_element

Class representing an element of a multi-field. If each instantiation of the class can represent another element, they all share the same characteristics. That is if the characteristics are set for one, they will be set for all the others. The characteristics can be set before instantiating the elements with the static Shared_multi_field_element::initialize method

Gudhi::persistence_fields::Shared_multi_field_element_with_small_characteristics< Unsigned_integer_type, class >

Class representing an element of a multi-field, such that productOfAllCharacteristics ^ 2 fits into the given `Unsigned_integer_type` template argument. If each instantiation of the class can represent another element, they all share the same characteristics. That is if the characteristics are set for one, they will be set for all the others. The characteristics can be set before instantiating the elements with the static Shared_multi_field_element_with_small_characteristics::initialize method

Gudhi::persistence_fields::Shared_Zp_field_element< Unsigned_integer_type, class >

Class representing an element of the \( \mathbb{F}_p \) field for any prime number \( p \). If each instantiation of the class can represent another element, they all share the same characteristics. That is if the characteristics are set for one, they will be set for all the others. The characteristics can be set before instantiating the elements with the static Shared_Zp_field_element::initialize method

Shared_Zp_field_element< Unsigned_integer_type, class >

Class representing an element of the \( \mathbb{F}_p \) field for any prime number \( p \). If each instantiation of the class can represent another element, they all share the same characteristics. That is if the characteristics are set for one, they will be set for all the others. The characteristics can be set before instantiating the elements with the static Shared_Zp_field_element::initialize method

Gudhi::skeleton_blocker::Skeleton_blocker_simple_geometric_traits< GeometryTrait >::Simple_geometric_vertex | Vertex with a point attached
Gudhi::skeleton_blocker::Simplex_around_vertex_iterator< SkeletonBlockerComplex, Link > |
Gudhi::skeleton_blocker::Simplex_around_vertex_iterator< Skeleton_blocker_complex, Link > |
Gudhi::skeleton_blocker::Simplex_coboundary_iterator< SkeletonBlockerComplex, Link > |
Gudhi::skeleton_blocker::Simplex_coboundary_iterator< Skeleton_blocker_complex, Link > |
Gudhi::coxeter_triangulation::Simplex_comparator< Permutahedral_representation_ > | A comparator class for Permutahedral_representation. The comparison is in lexicographic order first on vertices and then on ordered partitions with sorted parts. The lexicographic order forces that any face is larger than a coface
Gudhi::Simplex_tree< SimplexTreeOptions > | Simplex Tree data structure for representing simplicial complexes
Simplex_tree< SimplexTreeOptions > | Simplex Tree data structure for representing simplicial complexes
Gudhi::Simplex_tree_boundary_opposite_vertex_simplex_iterator< SimplexTree > | Iterator over the simplices of the boundary of a simplex and their opposite vertices
Gudhi::Simplex_tree_boundary_opposite_vertex_simplex_iterator< Simplex_tree > |
Gudhi::Simplex_tree_boundary_simplex_iterator< SimplexTree > | Iterator over the simplices of the boundary of a simplex
Gudhi::Simplex_tree_boundary_simplex_iterator< Simplex_tree > |
Gudhi::Simplex_tree_complex_simplex_iterator< SimplexTree > | Iterator over the simplices of a simplicial complex
Gudhi::Simplex_tree_complex_simplex_iterator< Simplex_tree > |
Gudhi::Simplex_tree_node_explicit_storage< SimplexTree > | Node of a simplex tree with filtration value and simplex key
Gudhi::Simplex_tree_node_explicit_storage< Simplex_tree > |
Gudhi::Simplex_tree_optimized_star_simplex_iterator< SimplexTree > | Iterator over the simplices of the star of a simplex
Gudhi::Simplex_tree_optimized_star_simplex_iterator< Simplex_tree > |
Gudhi::Simplex_tree_options_default |
Gudhi::Simplex_tree_options_full_featured |
Gudhi::Simplex_tree_options_minimal |
Gudhi::Simplex_tree_siblings< SimplexTree, MapContainer > | Data structure to store a set of nodes in a SimplexTree sharing the same parent node
Gudhi::Simplex_tree_simplex_vertex_iterator< SimplexTree > | Iterator over the vertices of a simplex in a SimplexTree
Gudhi::Simplex_tree_simplex_vertex_iterator< Simplex_tree > |
Gudhi::Simplex_tree_skeleton_simplex_iterator< SimplexTree > | Iterator over the simplices of the skeleton of a given dimension of the simplicial complex
Gudhi::Simplex_tree_skeleton_simplex_iterator< Simplex_tree > |
Gudhi::coxeter_triangulation::SimplexInCoxeterTriangulation | The concept SimplexInCoxeterTriangulation describes the requirements for a type to implement a representation of simplices in Freudenthal_triangulation or in Coxeter_triangulation
SimplexKey | Key type used as simplex identifier
SimplexTreeOptions | Concept of the template parameter for the class Gudhi::Simplex_tree<SimplexTreeOptions>
Gudhi::alpha_complex::SimplicialComplexForAlpha | The concept SimplicialComplexForAlpha describes the requirements for a type to implement a simplicial complex, that can be created from a Alpha_complex
Gudhi::alpha_complex::SimplicialComplexForAlpha3d | The concept SimplicialComplexForAlpha3d describes the requirements for a type to implement a simplicial complex, that can be created from a Alpha_complex_3d
Gudhi::cech_complex::SimplicialComplexForCech | The concept SimplicialComplexForCech describes the requirements for a type to implement a simplicial complex, that can be created from a Cech_complex
Gudhi::cech_complex::SimplicialComplexForMEB |
Gudhi::rips_complex::SimplicialComplexForRips | The concept SimplicialComplexForRips describes the requirements for a type to implement a simplicial complex, that can be created from a Rips_complex. The only available model for the moment is the Simplex_tree
Gudhi::witness_complex::SimplicialComplexForWitness | The concept SimplicialComplexForWitness describes the requirements for a type to implement a simplicial complex, used for example to build a Witness_complex or Strong_witness_complex
Gudhi::coxeter_triangulation::Size_iterator< T_it > | Auxiliary iterator class for sizes of parts in an ordered set partition
Gudhi::coxeter_triangulation::Size_iterator< typename T::const_iterator > |
Gudhi::skeleton_blocker::Skeleton_blocker_complex< SkeletonBlockerDS > | Abstract Simplicial Complex represented with a skeleton/blockers pair
Gudhi::skeleton_blocker::Skeleton_blocker_geometric_complex< Garland_heckbert_traits > |
Gudhi::skeleton_blocker::Skeleton_blocker_geometric_complex< Complex_geometric_traits > |
Gudhi::skeleton_blocker::Skeleton_blocker_sub_complex< ComplexType > | Simplicial subcomplex of a complex represented by a skeleton/blockers pair
Gudhi::skeleton_blocker::Skeleton_blocker_link_complex< Skeleton_blocker_complex > |
Gudhi::skeleton_blocker::Skeleton_blocker_link_complex< Skeleton_blocker_complex< SkeletonBlockerDS > > |
Gudhi::skeleton_blocker::Skeleton_blocker_link_superior< Skeleton_blocker_complex< SkeletonBlockerDS > > |
Gudhi::skeleton_blocker::Skeleton_blocker_link_complex< Skeleton_blocker_geometric_complex > |
Gudhi::skeleton_blocker::Skeleton_blocker_link_complex< Skeleton_blocker_complex< SkeletonBlockerGeometricDS > > |
Gudhi::skeleton_blocker::Skeleton_blocker_link_complex< ComplexType > | Class representing the link of a simplicial complex encoded by a skeleton/blockers pair. It inherits from Skeleton_blocker_sub_complex because such complex is a sub complex of a root complex
Gudhi::skeleton_blocker::Skeleton_blocker_link_superior< SkeletonBlockerComplex > |
Gudhi::skeleton_blocker::Skeleton_blocker_link_superior< ComplexType > | Class representing the link of a simplicial complex encoded by a skeleton/blockers pair. It computes only vertices greater than the simplex used to build the link
Gudhi::skeleton_blocker::Skeleton_blocker_complex< SkeletonBlockerGeometricDS > |
Gudhi::skeleton_blocker::Skeleton_blocker_geometric_complex< SkeletonBlockerGeometricDS > | Class that represents a geometric complex that can be simplified. The class allows access to points of vertices
Gudhi::skeleton_blocker::Skeleton_blocker_complex_visitor< Vertex_handle > | Interface for a visitor of a simplicial complex
Gudhi::skeleton_blocker::Dummy_complex_visitor< GeometricSimplifiableComplex::Vertex_handle > |
Gudhi::contraction::Skeleton_blocker_contractor< GeometricSimplifiableComplex, EdgeProfile > | Class that allows to contract iteratively edges of a simplicial complex
Gudhi::skeleton_blocker::Dummy_complex_visitor< Vertex_handle > | A dummy visitor of a simplicial complex that does nothing
Gudhi::contraction::Skeleton_blocker_contractor< Complex > |
Gudhi::skeleton_blocker::Print_complex_visitor< Vertex_handle > | A visitor that prints the visit information
Gudhi::skeleton_blocker::Skeleton_blocker_off_flag_visitor_reader< Complex > | Off reader visitor that can be passed to Off_reader to read a Skeleton_blocker_complex
Gudhi::skeleton_blocker::Skeleton_blocker_off_reader< Complex > | Class that allows to load a Skeleton_blocker_complex from an off file
Gudhi::skeleton_blocker::Skeleton_blocker_off_visitor_reader< Complex > | Off reader visitor that can be passed to Off_reader to read a Skeleton_blocker_complex
Gudhi::skeleton_blocker::Skeleton_blocker_simplex< T > | Abstract simplex used in Skeleton blockers data-structure
Gudhi::cubical_complex::Bitmap_cubical_complex< T >::Skeleton_simplex_range | A range containing all the cells of dimension at most k
Gudhi::skeleton_blocker::SkeletonBlockerDS | Concept for the template class passed for Skeleton_blocker_complex. Most importantly, it contains the nodes for vertices and edges (Graph_vertex and Graph_edge) that are stored in the simplicial complex. The user can redefine these classes to attach additional information to vertices and edges
Gudhi::skeleton_blocker::SkeletonBlockerGeometricDS< GeometryTrait > | Concept for template class of Skeleton_blocker_geometric_complex . It must specify a GeometryTrait which contains a Point definition
Gudhi::skeleton_blocker::Skeleton_blocker_simple_geometric_traits< Geometry_trait > |
Gudhi::skeleton_blocker::Skeleton_blocker_simple_geometric_traits< GeometryTrait > | Simple traits that is a model of SkeletonBlockerGeometricDS and can be passed as a template argument to Skeleton_blocker_geometric_complex
Gudhi::skeleton_blocker::Skeleton_blocker_simple_traits | Simple traits that is a model of SkeletonBlockerDS and can be passed as a template argument to Skeleton_blocker_complex
Gudhi::skeleton_blocker::Skeleton_blocker_simple_geometric_traits< Geometry_trait > |
Gudhi::skeleton_blocker::Skeleton_blocker_simple_geometric_traits< GeometryTrait > | Simple traits that is a model of SkeletonBlockerGeometricDS and can be passed as a template argument to Skeleton_blocker_geometric_complex
Gudhi::Persistence_representations::Sliced_Wasserstein | A class implementing the Sliced Wasserstein kernel
Gudhi::rips_complex::Sparse_rips_complex< Filtration_value > | Sparse Rips complex data structure
Gudhi::Persistence_representations::squared_distance_from_diagonal_scaling |
Gudhi::witness_complex::Strong_witness_complex< Nearest_landmark_table_ > | Constructs strong witness complex for a given table of nearest landmarks with respect to witnesses
Gudhi::witness_complex::Euclidean_strong_witness_complex< K > |
Gudhi::witness_complex::Strong_witness_complex< std::vector< Gudhi::spatial_searching::Kd_tree_search< Kernel_, std::vector< Kernel_::Point_d > >::INS_range > > |
Gudhi::witness_complex::Euclidean_strong_witness_complex< Kernel_ > | Constructs strong witness complex for given sets of witnesses and landmarks in Euclidean space
Gudhi::tangential_complex::Tangential_complex< Kernel_, DimensionTag, Concurrency_tag, Triangulation_ > | Tangential complex data structure
Gudhi::cubical_complex::Bitmap_cubical_complex_base< T >::Top_dimensional_cells_iterator | Iterator through top dimensional cells of the complex. The cells appear in order they are stored in the structure (i.e. in lexicographical order)
Gudhi::cubical_complex::Bitmap_cubical_complex_base< T >::Top_dimensional_cells_range | Range corresponding to Top_dimensional_cells_iterator
Gudhi::Toplex_map | Toplex map data structure for representing unfiltered simplicial complexes
Gudhi::Persistence_representations::Topological_data_with_averages | The concept Topological_data_with_averages describes the requirements for a type to implement a container that allows computations of averages. Note that the average object after being computed is stored in *this
Gudhi::Persistence_representations::Topological_data_with_distances | The concept Topological_data_with_distances describes the requirements for a type to implement a container that allows computations of distance to another contained of that type
Gudhi::Persistence_representations::Topological_data_with_scalar_product | The concept Topological_data_with_scalar_product describes the requirements for a type to implement a container that allows computations of scalar products
Gudhi::coxeter_triangulation::Translate< Function_ > | Translates the zero-set of the function by a vector. The underlying function corresponds to f(x-off), where off is the offset vector
Gudhi::skeleton_blocker::Triangle_around_vertex_iterator< Complex, LinkType > | Iterator over the triangles that are adjacent to a vertex of the simplicial complex
Gudhi::skeleton_blocker::Triangle_around_vertex_iterator< Skeleton_blocker_complex, Superior_link > |
Gudhi::skeleton_blocker::Triangle_iterator< SkeletonBlockerComplex > | Iterator over the triangles of the simplicial complex
Gudhi::skeleton_blocker::Triangle_iterator< Skeleton_blocker_complex > |
Gudhi::coxeter_triangulation::TriangulationForManifoldTracing | The concept TriangulationForManifoldTracing describes the requirements for a type to implement a triangulation class used for example in Manifold_tracing
std::tuple_element< I, Gudhi::persistence_matrix::Persistence_interval< Dimension, Event_value > > | Partial specialization of std::tuple_element for Gudhi::persistence_matrix::Persistence_interval
std::tuple_size< Gudhi::persistence_matrix::Persistence_interval< Dimension, Event_value > > | Partial specialization of std::tuple_size for Gudhi::persistence_matrix::Persistence_interval
Gudhi::persistence_matrix::Unordered_set_column< Master_matrix > | Column class following the PersistenceMatrixColumn concept
Gudhi::persistence_matrix::Unordered_set_column< Matrix< PersistenceMatrixOptions > > |
Gudhi::contraction::Valid_contraction_policy< EdgeProfile > | Policy to specify if an edge contraction is valid or not
Gudhi::contraction::Dummy_valid_contraction< EdgeProfile > | Policy that accept all edge contraction
Gudhi::contraction::Link_condition_valid_contraction< EdgeProfile > | Policy that only accept edges verifying the link condition (and therefore whose contraction preserving homotopy type)
Gudhi::persistence_matrix::Vector_column< Master_matrix > | Column class following the PersistenceMatrixColumn concept
Gudhi::persistence_matrix::Vector_column< Matrix< PersistenceMatrixOptions > > |
Gudhi::Persistence_representations::Vector_distances_in_diagram< F > | A class implementing persistence vectors
Gudhi::Persistence_representations::Vectorized_topological_data | The concept Vectorized_topological_data describes the requirements for a type to implement a container that allows vectorization
Gudhi::skeleton_blocker::SkeletonBlockerDS::Vertex_handle |
Gudhi::coxeter_triangulation::Vertex_iterator< Permutahedral_representation > | Iterator over the vertices of a simplex represented by its permutahedral representation
Gudhi::skeleton_blocker::Vertex_iterator< SkeletonBlockerComplex > | Iterator on the vertices of a simplicial complex
Gudhi::coxeter_triangulation::Vertex_iterator< Self > |
Gudhi::skeleton_blocker::Vertex_iterator< Skeleton_blocker_complex > |
VertexHandle | Handle type for the vertices of a cell complex
Gudhi::Persistence_representations::weight_by_setting_maximal_interval_to_have_length_one |
Gudhi::witness_complex::Witness_complex< Nearest_landmark_table_ > | Constructs (weak) witness complex for a given table of nearest landmarks with respect to witnesses
Gudhi::witness_complex::Euclidean_witness_complex< K > |
Gudhi::witness_complex::Witness_complex< std::vector< Gudhi::spatial_searching::Kd_tree_search< Kernel_, std::vector< Kernel_::Point_d > >::INS_range > > |
Gudhi::witness_complex::Euclidean_witness_complex< Kernel_ > | Constructs (weak) witness complex for given sets of witnesses and landmarks in Euclidean space
Gudhi::persistence_fields::Z2_field_element | Class representing an element of the \( \mathbb{F}_2 \) field
Z2_field_element | Class representing an element of the \( \mathbb{F}_2 \) field
Gudhi::persistence_fields::Z2_field_operators | Class defining operators for the \( \mathbb{F}_2 \) field
Z2_field_operators | Class defining operators for the \( \mathbb{F}_2 \) field
Gudhi::zigzag_persistence::Zigzag_persistence< ZigzagOptions > | Class computing the zigzag persistent homology of a zigzag sequence. Algorithm based on [zigzag]
Gudhi::zigzag_persistence::ZigzagOptions | List of options used for the zigzag persistence computation
Gudhi::persistence_fields::Zp_field_element< characteristic, Unsigned_integer_type, class > | Class representing an element of the \( \mathbb{F}_p \) field for any prime number \( p \)
Zp_field_element< characteristic, Unsigned_integer_type, class > | Class representing an element of the \( \mathbb{F}_p \) field for any prime number \( p \)
Gudhi::persistence_fields::Zp_field_operators< Unsigned_integer_type, class > | Class defining operators for the \( \mathbb{F}_p \) field for any prime number \( p \)
Zp_field_operators< Unsigned_integer_type, class > | Class defining operators for the \( \mathbb{F}_p \) field for any prime number \( p \)