11 #ifndef INCLUDE_PERSISTENT_COHOMOLOGY_INTERFACE_H_
12 #define INCLUDE_PERSISTENT_COHOMOLOGY_INTERFACE_H_
14 #include <gudhi/Persistent_cohomology.h>
20 #include <unordered_map>
24 template<
class FilteredComplex>
25 class Persistent_cohomology_interface :
public
26 persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp> {
28 typedef persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp> Base;
32 struct cmp_intervals_by_dim_then_length {
33 template<
typename Persistent_
interval>
34 bool operator()(
const Persistent_interval & p1,
const Persistent_interval & p2) {
35 if (std::get<0>(p1) == std::get<0>(p2)) {
36 auto& i1 = std::get<1>(p1);
37 auto& i2 = std::get<1>(p2);
38 return std::get<1>(i1) - std::get<0>(i1) > std::get<1>(i2) - std::get<0>(i2);
41 return (std::get<0>(p1) > std::get<0>(p2));
47 Persistent_cohomology_interface(
FilteredComplex* stptr,
bool persistence_dim_max=
false)
48 : Base(*stptr, persistence_dim_max),
52 void compute_persistence(
int homology_coeff_field,
double min_persistence) {
57 std::vector<std::pair<int, std::pair<double, double>>> get_persistence() {
58 std::vector<std::pair<int, std::pair<double, double>>> persistence;
60 persistence.reserve(persistent_pairs.size());
61 for (
auto pair : persistent_pairs) {
62 persistence.emplace_back(stptr_->dimension(get<0>(pair)),
63 std::make_pair(stptr_->filtration(get<0>(pair)),
64 stptr_->filtration(get<1>(pair))));
67 cmp_intervals_by_dim_then_length cmp;
68 std::sort(std::begin(persistence), std::end(persistence), cmp);
77 std::vector<std::vector<int>> cofaces_of_cubical_persistence_pairs() {
81 auto&& pairs = persistent_cohomology::Persistent_cohomology<
FilteredComplex,
82 persistent_cohomology::Field_Zp>::get_persistent_pairs();
85 std::vector<std::size_t> max_splx;
86 for (
auto splx : stptr_->top_dimensional_cells_range())
87 max_splx.push_back(splx);
90 std::unordered_map<std::size_t, int> order;
92 for (
unsigned int i = 0; i < max_splx.size(); i++) order.emplace(max_splx[i], i);
94 std::vector<std::vector<int>> persistence_pairs;
95 for (
auto pair : pairs) {
96 int h = stptr_->dimension(get<0>(pair));
98 std::size_t face0 = stptr_->get_top_dimensional_coface_of_a_cell(get<0>(pair));
100 int splx0 = order[face0];
103 if (get<1>(pair) != stptr_->null_simplex()){
105 std::size_t face1 = stptr_->get_top_dimensional_coface_of_a_cell(get<1>(pair));
107 splx1 = order[face1];
109 persistence_pairs.push_back({ h, splx0, splx1 });
111 return persistence_pairs;
114 std::vector<std::pair<std::vector<int>, std::vector<int>>> persistence_pairs() {
115 std::vector<std::pair<std::vector<int>, std::vector<int>>> persistence_pairs;
117 persistence_pairs.reserve(pairs.size());
118 std::vector<int> birth;
119 std::vector<int> death;
120 for (
auto pair : pairs) {
122 if (get<0>(pair) != stptr_->null_simplex()) {
123 for (
auto vertex : stptr_->simplex_vertex_range(get<0>(pair))) {
124 birth.push_back(vertex);
129 if (get<1>(pair) != stptr_->null_simplex()) {
130 death.reserve(birth.size()+1);
131 for (
auto vertex : stptr_->simplex_vertex_range(get<1>(pair))) {
132 death.push_back(vertex);
136 persistence_pairs.emplace_back(birth, death);
138 return persistence_pairs;
143 typedef std::pair<std::vector<std::vector<int>>, std::vector<std::vector<int>>> Generators;
145 Generators lower_star_generators() {
148 auto& diags = out.first;
150 auto& diagsinf = out.second;
152 auto s = std::get<0>(pair);
153 auto t = std::get<1>(pair);
154 int dim = stptr_->dimension(s);
155 auto v = stptr_->vertex_with_same_filtration(s);
156 if(t == stptr_->null_simplex()) {
157 while(diagsinf.size() < dim+1) diagsinf.emplace_back();
158 diagsinf[dim].push_back(v);
160 while(diags.size() < dim+1) diags.emplace_back();
161 auto w = stptr_->vertex_with_same_filtration(t);
162 auto& d = diags[dim];
163 d.insert(d.end(), { v, w });
171 Generators flag_generators() {
174 auto& diags = out.first;
176 auto& diagsinf = out.second;
178 auto s = std::get<0>(pair);
179 auto t = std::get<1>(pair);
180 int dim = stptr_->dimension(s);
181 bool infinite = t == stptr_->null_simplex();
184 auto v = *std::begin(stptr_->simplex_vertex_range(s));
185 if(diagsinf.size()==0)diagsinf.emplace_back();
186 diagsinf[0].push_back(v);
188 auto e = stptr_->edge_with_same_filtration(s);
189 auto&& e_vertices = stptr_->simplex_vertex_range(e);
190 auto i = std::begin(e_vertices);
193 GUDHI_CHECK(++i==std::end(e_vertices),
"must be an edge");
194 while(diagsinf.size() < dim+1) diagsinf.emplace_back();
195 auto& d = diagsinf[dim];
196 d.insert(d.end(), { v1, v2 });
199 auto et = stptr_->edge_with_same_filtration(t);
200 auto&& et_vertices = stptr_->simplex_vertex_range(et);
201 auto it = std::begin(et_vertices);
204 GUDHI_CHECK(++it==std::end(et_vertices),
"must be an edge");
206 auto v = *std::begin(stptr_->simplex_vertex_range(s));
207 if(diags.size()==0)diags.emplace_back();
209 d.insert(d.end(), { v, w1, w2 });
211 auto es = stptr_->edge_with_same_filtration(s);
212 auto&& es_vertices = stptr_->simplex_vertex_range(es);
213 auto is = std::begin(es_vertices);
216 GUDHI_CHECK(++is==std::end(es_vertices),
"must be an edge");
217 while(diags.size() < dim+1) diags.emplace_back();
218 auto& d = diags[dim];
219 d.insert(d.end(), { v1, v2, w1, w2 });
void compute_persistent_cohomology(Filtration_value min_interval_length=0)
Compute the persistent homology of the filtered simplicial complex.
Definition: Persistent_cohomology.h:172
void init_coefficients(int charac)
Initializes the coefficient field.
Definition: Persistent_cohomology.h:156
const std::vector< Persistent_interval > & get_persistent_pairs() const
Returns a list of persistence birth and death FilteredComplex::Simplex_handle pairs.
Definition: Persistent_cohomology.h:672
The concept FilteredComplex describes the requirements for a type to implement a filtered cell comple...
Definition: FilteredComplex.h:17