11#ifndef BITMAP_CUBICAL_COMPLEX_BASE_H_
12#define BITMAP_CUBICAL_COMPLEX_BASE_H_
14#include <gudhi/Debug_utils.h>
16#include <boost/config.hpp>
17#include <boost/iterator/counting_iterator.hpp>
18#include <boost/range/iterator_range.hpp>
35namespace cubical_complex {
59 typedef T filtration_type;
159 std::vector<unsigned> coface_counter = this->compute_counter_for_given_cell(coface);
160 std::vector<unsigned> face_counter = this->compute_counter_for_given_cell(face);
163 int number_of_position_in_which_counters_do_not_agree = -1;
164 std::size_t number_of_full_faces_that_comes_before = 0;
165 for (std::size_t i = 0; i != coface_counter.size(); ++i) {
166 if ((coface_counter[i] % 2 == 1) && (number_of_position_in_which_counters_do_not_agree == -1)) {
167 ++number_of_full_faces_that_comes_before;
169 if (coface_counter[i] != face_counter[i]) {
170 if (number_of_position_in_which_counters_do_not_agree != -1) {
171 std::cerr <<
"Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.\n";
172 throw std::logic_error(
173 "Cells given to compute_incidence_between_cells procedure do not form a pair of coface-face.");
175 number_of_position_in_which_counters_do_not_agree = i;
180 if (number_of_full_faces_that_comes_before % 2) incidence = -1;
182 if (coface_counter[number_of_position_in_which_counters_do_not_agree] + 1 ==
183 face_counter[number_of_position_in_which_counters_do_not_agree]) {
227 inline unsigned dimension()
const {
return sizes.size(); }
232 inline std::size_t
size()
const {
return this->data.size(); }
291 typedef typename std::vector<std::size_t> Boundary_range;
303 typedef typename std::vector<std::size_t> Coboundary_range;
317 typedef std::input_iterator_tag iterator_category;
318 typedef std::size_t value_type;
319 typedef std::ptrdiff_t difference_type;
320 typedef value_type* pointer;
321 typedef value_type reference;
328 while ((dim != this->b->
dimension()) && (this->counter[dim] == this->b->sizes[dim] - 1)) ++dim;
331 ++this->counter[dim];
332 for (std::size_t i = 0; i != dim; ++i) {
333 this->counter[i] = 0;
348 if (this->b != rhs.b)
return false;
349 if (this->counter.size() != rhs.counter.size())
return false;
350 for (std::size_t i = 0; i != this->counter.size(); ++i) {
351 if (this->counter[i] != rhs.counter[i])
return false;
365 std::size_t operator*() {
return this->compute_index_in_bitmap(); }
367 std::size_t compute_index_in_bitmap()
const {
368 std::size_t index = 0;
369 for (std::size_t i = 0; i != this->counter.size(); ++i) {
370 index += (2 * this->counter[i] + 1) * this->b->multipliers[i];
375 void print_counter()
const {
376 for (std::size_t i = 0; i != this->counter.size(); ++i) {
377 std::clog << this->counter[i] <<
" ";
383 std::vector<std::size_t> counter;
400 for (std::size_t i = 0; i != this->
dimension(); ++i) {
401 a.counter[i] = this->sizes[i] - 1;
429 class Vertices_iterator {
431 typedef std::input_iterator_tag iterator_category;
432 typedef std::size_t value_type;
433 typedef std::ptrdiff_t difference_type;
434 typedef value_type* pointer;
435 typedef value_type reference;
439 Vertices_iterator operator++() {
442 while ((dim != this->b->dimension()) && (this->counter[dim] == this->b->sizes[dim])) ++dim;
444 if (dim != this->b->dimension()) {
445 ++this->counter[dim];
446 for (std::size_t i = 0; i != dim; ++i) {
447 this->counter[i] = 0;
455 Vertices_iterator operator++(
int) {
456 Vertices_iterator result = *
this;
461 bool operator==(
const Vertices_iterator& rhs)
const {
462 if (this->b != rhs.b)
return false;
463 GUDHI_CHECK(this->counter.size() == rhs.counter.size(),
"impossible");
464 for (std::size_t i = 0; i != this->counter.size(); ++i) {
465 if (this->counter[i] != rhs.counter[i])
return false;
470 bool operator!=(
const Vertices_iterator& rhs)
const {
return !(*
this == rhs); }
479 std::size_t operator*()
const {
return this->compute_index_in_bitmap(); }
481 std::size_t compute_index_in_bitmap()
const {
482 std::size_t index = 0;
483 for (std::size_t i = 0; i != this->counter.size(); ++i) {
484 index += 2 * this->counter[i] * this->b->multipliers[i];
489 void print_counter()
const {
490 for (std::size_t i = 0; i != this->counter.size(); ++i) {
491 std::clog << this->counter[i] <<
" ";
494 friend class Bitmap_cubical_complex_base;
497 std::vector<std::size_t> counter;
498 Bitmap_cubical_complex_base* b;
504 Vertices_iterator vertices_iterator_begin() {
505 Vertices_iterator a(
this);
512 Vertices_iterator vertices_iterator_end() {
513 Vertices_iterator a(
this);
514 for (std::size_t i = 0; i != this->
dimension(); ++i) {
515 a.counter[i] = this->sizes[i];
524 class Vertices_range {
528 Vertices_iterator begin() {
return b->vertices_iterator_begin(); }
530 Vertices_iterator end() {
return b->vertices_iterator_end(); }
537 Vertices_range vertices_range() {
return Vertices_range(
this); }
544 inline std::size_t number_cells()
const {
return this->total_number_of_cells; }
552 template <
class F>
void for_each_vertex(F&&f) {
553 for_each_vertex_rec(f, 0, multipliers.size()-1);
557 std::vector<unsigned> sizes;
558 std::vector<unsigned> multipliers;
560 std::size_t total_number_of_cells;
562 template <
class F>
void for_each_vertex_rec(F&&f, std::size_t base,
int dim);
563 void propagate_from_vertices_rec(
int special_dim,
int current_dim, std::size_t base);
565 void set_up_containers(
const std::vector<unsigned>& sizes,
bool is_pos_inf) {
567 unsigned multiplier = 1;
568 for (std::size_t i = 0; i != sizes.size(); ++i) {
569 this->sizes.push_back(sizes[i]);
570 this->multipliers.push_back(multiplier);
571 multiplier *= 2 * sizes[i] + 1;
574 this->data = std::vector<T>(multiplier, std::numeric_limits<T>::infinity());
576 this->data = std::vector<T>(multiplier, -std::numeric_limits<T>::infinity());
577 this->total_number_of_cells = multiplier;
580 std::size_t compute_position_in_bitmap(
const std::vector<unsigned>& counter) {
581 std::size_t position = 0;
582 for (std::size_t i = 0; i != this->multipliers.size(); ++i) {
583 position += this->multipliers[i] * counter[i];
588 std::vector<unsigned> compute_counter_for_given_cell(std::size_t cell)
const {
589 std::vector<unsigned> counter;
590 counter.reserve(this->sizes.size());
591 for (std::size_t dim = this->sizes.size(); dim > 1; --dim) {
592 std::size_t quot = cell / this->multipliers[dim - 1];
593 cell = cell % this->multipliers[dim - 1];
594 counter.push_back(quot);
597 counter.push_back(cell);
598 std::reverse(counter.begin(), counter.end());
601 void read_perseus_style_file(
const char* perseus_style_file);
602 void setup_bitmap_based_on_top_dimensional_cells_list(
const std::vector<unsigned>& sizes_in_following_directions,
603 const std::vector<T>& top_dimensional_cells);
604 void setup_bitmap_based_on_vertices(
const std::vector<unsigned>& sizes_in_following_directions,
605 const std::vector<T>& vertices);
609 const std::vector<bool>& directions,
bool input_top_cells);
615 std::pair<T, T> min_max = this->min_max_filtration();
616 T dx = (min_max.second - min_max.first) / (T)number_of_bins;
619 for (std::size_t i = 0; i != this->data.size(); ++i) {
621 std::clog <<
"Before binning : " << this->data[i] << std::endl;
623 this->data[i] = min_max.first + dx * (this->data[i] - min_max.first) / number_of_bins;
625 std::clog <<
"After binning : " << this->data[i] << std::endl;
632 std::pair<T, T> min_max = this->min_max_filtration();
634 std::size_t number_of_bins = (min_max.second - min_max.first) / diameter_of_bin;
636 for (std::size_t i = 0; i != this->data.size(); ++i) {
638 std::clog <<
"Before binning : " << this->data[i] << std::endl;
640 this->data[i] = min_max.first + diameter_of_bin * (this->data[i] - min_max.first) / number_of_bins;
642 std::clog <<
"After binning : " << this->data[i] << std::endl;
649 std::pair<T, T> min_max(std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::infinity());
650 for (std::size_t i = 0; i != this->data.size(); ++i) {
651 if (this->data[i] < min_max.first) min_max.first = this->data[i];
652 if (this->data[i] > min_max.second) min_max.second = this->data[i];
659 this->set_up_containers(sizes,
true);
664 const std::vector<unsigned>& sizes_in_following_directions,
const std::vector<T>& top_dimensional_cells) {
665 this->set_up_containers(sizes_in_following_directions,
true);
666 std::size_t number_of_top_dimensional_elements = std::accumulate(std::begin(sizes_in_following_directions),
667 std::end(sizes_in_following_directions), std::size_t(1),
668 std::multiplies<std::size_t>());
669 if (number_of_top_dimensional_elements != top_dimensional_cells.size()) {
670 std::cerr <<
"Error in constructor Bitmap_cubical_complex_base ( std::vector<unsigned> "
671 <<
"sizes_in_following_directions, std::vector<T> top_dimensional_cells ). Number of top dimensional "
672 <<
"elements that follow from sizes_in_following_directions vector is different from the size of "
673 <<
"top_dimensional_cells vector."
675 throw std::invalid_argument(
676 "Error in constructor Bitmap_cubical_complex_base( std::vector<unsigned> sizes_in_following_directions,"
677 "std::vector<T> top_dimensional_cells ). Number of top dimensional elements that follow from "
678 "sizes_in_following_directions vector is different from the size of top_dimensional_cells vector.");
681 std::size_t index = 0;
682 for (
auto it = this->top_dimensional_cells_iterator_begin();
683 it != this->top_dimensional_cells_iterator_end(); ++it) {
684 this->get_cell_data(*it) = top_dimensional_cells[index];
687 this->impose_lower_star_filtration();
691void Bitmap_cubical_complex_base<T>::setup_bitmap_based_on_vertices(
const std::vector<unsigned>& sizes_in_following_directions,
692 const std::vector<T>& vertices) {
693 std::vector<unsigned> top_cells_sizes;
694 std::transform (sizes_in_following_directions.begin(), sizes_in_following_directions.end(), std::back_inserter(top_cells_sizes),
695 [](
int i){ return i-1;});
696 this->set_up_containers(top_cells_sizes,
false);
697 std::size_t number_of_vertices = std::accumulate(std::begin(sizes_in_following_directions),
698 std::end(sizes_in_following_directions), (std::size_t)1,
699 std::multiplies<std::size_t>());
700 if (number_of_vertices != vertices.size()) {
701 std::cerr <<
"Error in constructor Bitmap_cubical_complex_base ( std::vector<unsigned> "
702 <<
"sizes_in_following_directions, std::vector<T> vertices ). Number of vertices "
703 <<
"elements that follow from sizes_in_following_directions vector is different from the size of "
704 <<
"vertices vector."
706 throw std::invalid_argument(
707 "Error in constructor Bitmap_cubical_complex_base( std::vector<unsigned> sizes_in_following_directions,"
708 "std::vector<T> vertices ). Number of vertices elements that follow from "
709 "sizes_in_following_directions vector is different from the size of vertices vector.");
712 for_each_vertex([
this, &vertices, index=(std::size_t)0] (
auto cell)
mutable { get_cell_data(cell) = vertices[index++]; });
713 this->impose_lower_star_filtration_from_vertices();
718 if (this->get_dimension_of_a_cell(splx) == this->dimension()){
return splx;}
720 for (
auto v : this->get_coboundary_of_a_cell(splx)){
721 if(this->get_cell_data(v) == this->get_cell_data(splx)){
722 return this->get_top_dimensional_coface_of_a_cell(v);
726 BOOST_UNREACHABLE_RETURN(-2);
731 if (this->get_dimension_of_a_cell(splx) == 0){
return splx;}
733 for (
auto v : this->get_boundary_of_a_cell(splx)){
734 if(this->get_cell_data(v) == this->get_cell_data(splx)){
735 return this->get_vertex_of_a_cell(v);
739 BOOST_UNREACHABLE_RETURN(-2);
744 const std::vector<T>& cells,
bool input_top_cells) {
745 if (input_top_cells) {
746 this->setup_bitmap_based_on_top_dimensional_cells_list(sizes_in_following_directions, cells);
748 this->setup_bitmap_based_on_vertices(sizes_in_following_directions, cells);
754 std::ifstream inFiltration(perseus_style_file);
755 if(!inFiltration)
throw std::ios_base::failure(std::string(
"Could not open the file ") + perseus_style_file);
756 unsigned dimensionOfData;
757 inFiltration >> dimensionOfData;
760 std::clog <<
"dimensionOfData : " << dimensionOfData << std::endl;
763 std::vector<unsigned> sizes;
764 sizes.reserve(dimensionOfData);
766 std::size_t dimensions = 1;
767 for (std::size_t i = 0; i != dimensionOfData; ++i) {
768 unsigned size_in_this_dimension;
769 inFiltration >> size_in_this_dimension;
770 sizes.push_back(size_in_this_dimension);
771 dimensions *= size_in_this_dimension;
773 std::clog <<
"size_in_this_dimension : " << size_in_this_dimension << std::endl;
776 this->set_up_containers(sizes,
true);
778 Bitmap_cubical_complex_base<T>::Top_dimensional_cells_iterator it = this->top_dimensional_cells_iterator_begin();
780 T filtrationLevel = 0.;
781 std::size_t filtration_counter = 0;
782 while (!inFiltration.eof()) {
784 getline(inFiltration, line);
785 if (line.length() != 0) {
786 int n = sscanf(line.c_str(),
"%lf", &filtrationLevel);
788 std::string perseus_error(
"Bad Perseus file format. This line is incorrect : " + line);
789 throw std::ios_base::failure(perseus_error.c_str());
793 std::clog <<
"Cell of an index : " << it.compute_index_in_bitmap()
794 <<
" and dimension: " << this->get_dimension_of_a_cell(it.compute_index_in_bitmap())
795 <<
" get the value : " << filtrationLevel << std::endl;
797 this->get_cell_data(*it) = filtrationLevel;
799 ++filtration_counter;
803 if (filtration_counter != dimensions) {
804 std::string perseus_error(
"Bad Perseus file format. Read " + std::to_string(filtration_counter) +
" expected " + \
805 std::to_string(dimensions) +
" values");
806 throw std::ios_base::failure(perseus_error);
809 inFiltration.close();
810 this->impose_lower_star_filtration();
815 const std::vector<bool>& directions) {
819 this->read_perseus_style_file(perseus_style_file);
824 const std::vector<bool>& directions) {
828 this->set_up_containers(sizes,
true);
833 const std::vector<T>& cells,
834 const std::vector<bool>& directions,
835 bool input_top_cells) {
839 if (input_top_cells) {
840 this->setup_bitmap_based_on_top_dimensional_cells_list(dimensions, cells);
842 this->setup_bitmap_based_on_vertices(dimensions, cells);
848 this->read_perseus_style_file(perseus_style_file);
853 std::vector<std::size_t> boundary_elements;
856 boundary_elements.reserve(this->dimension() * 2);
858 std::size_t sum_of_dimensions = 0;
859 std::size_t cell1 = cell;
860 for (std::size_t i = this->multipliers.size(); i > 1; --i) {
861 unsigned position = cell1 / this->multipliers[i - 1];
862 cell1 = cell1 % this->multipliers[i - 1];
863 if (position % 2 == 1) {
864 if (sum_of_dimensions % 2) {
865 boundary_elements.push_back(cell + this->multipliers[i - 1]);
866 boundary_elements.push_back(cell - this->multipliers[i - 1]);
868 boundary_elements.push_back(cell - this->multipliers[i - 1]);
869 boundary_elements.push_back(cell + this->multipliers[i - 1]);
875 if (cell1 % 2 == 1) {
876 if (sum_of_dimensions % 2) {
877 boundary_elements.push_back(cell + 1);
878 boundary_elements.push_back(cell - 1);
880 boundary_elements.push_back(cell - 1);
881 boundary_elements.push_back(cell + 1);
886 return boundary_elements;
891 std::vector<unsigned> counter = this->compute_counter_for_given_cell(cell);
892 std::vector<std::size_t> coboundary_elements;
893 std::size_t cell1 = cell;
894 for (std::size_t i = this->multipliers.size(); i > 1; --i) {
896 unsigned position = cell1 / this->multipliers[i - 1];
897 cell1 = cell1 % this->multipliers[i - 1];
898 if (position % 2 == 0) {
899 if ((cell > this->multipliers[i - 1]) && (counter[i - 1] != 0)) {
900 coboundary_elements.push_back(cell - this->multipliers[i - 1]);
902 if ((cell + this->multipliers[i - 1] < this->data.size()) && (counter[i - 1] != 2 * this->sizes[i - 1])) {
903 coboundary_elements.push_back(cell + this->multipliers[i - 1]);
907 if (cell1 % 2 == 0) {
908 if ((cell > 1) && (counter[0] != 0)) {
909 coboundary_elements.push_back(cell - 1);
911 if ((cell + 1 < this->data.size()) && (counter[0] != 2 * this->sizes[0])) {
912 coboundary_elements.push_back(cell + 1);
915 return coboundary_elements;
921 std::clog <<
"\n\n\n Computing position o a cell of an index : " << cell << std::endl;
923 unsigned dimension = 0;
924 for (std::size_t i = this->multipliers.size(); i > 1; --i) {
925 unsigned position = cell / this->multipliers[i - 1];
926 std::size_t newcell = cell % this->multipliers[i - 1];
929 std::clog <<
"i-1 :" << i - 1 << std::endl;
930 std::clog <<
"cell : " << cell << std::endl;
931 std::clog <<
"position : " << position << std::endl;
932 std::clog <<
"multipliers[" << i - 1 <<
"] = " << this->multipliers[i - 1] << std::endl;
935 if (position % 2 == 1) {
937 std::clog <<
"Nonzero length in this direction \n";
945 std::clog <<
"i-1 :" << 0 << std::endl;
946 std::clog <<
"cell : " << cell << std::endl;
947 std::clog <<
"position : " << cell << std::endl;
948 std::clog <<
"multipliers[" << 0 <<
"] = " << 1 << std::endl;
953 std::clog <<
"Nonzero length in this direction \n";
963 return this->data[cell];
969 std::vector<bool> is_this_cell_considered(this->data.size(),
false);
971 std::vector<std::size_t> indices_to_consider;
974 for (
auto it = this->top_dimensional_cells_iterator_begin();
975 it != this->top_dimensional_cells_iterator_end(); ++it) {
976 indices_to_consider.push_back(it.compute_index_in_bitmap());
979 while (indices_to_consider.size()) {
981 std::clog <<
"indices_to_consider in this iteration \n";
982 for (
auto index : indices_to_consider) {
983 std::clog << index <<
" ";
986 std::vector<std::size_t> new_indices_to_consider;
987 for (
auto index : indices_to_consider) {
988 std::vector<std::size_t> bd = this->get_boundary_of_a_cell(index);
989 for (
auto boundary : bd) {
991 std::clog <<
"filtration of a cell : " << boundary <<
" is : " << this->data[boundary]
992 <<
" while of a cell: " << index <<
" is: " << this->data[index]
995 if (this->data[boundary] > this->data[index]) {
996 this->data[boundary] = this->data[index];
998 std::clog <<
"Setting the value of a cell : " << boundary
999 <<
" to : " << this->data[index] << std::endl;
1002 if (is_this_cell_considered[boundary] ==
false) {
1003 new_indices_to_consider.push_back(boundary);
1004 is_this_cell_considered[boundary] =
true;
1008 indices_to_consider.swap(new_indices_to_consider);
1012template <
typename T>
1016 for(std::size_t i = 0; i < sizes[dim] + 1; ++i)
1017 for_each_vertex_rec(f, base + multipliers[dim] * 2 * i, dim - 1);
1019 for(std::size_t i = 0; i < sizes[0] + 1; ++i)
1023template <
typename T>
1025 int max_dim = multipliers.size()-1;
1026 for (
int dim = max_dim; dim >= 0; --dim)
1027 propagate_from_vertices_rec(dim, max_dim, 0);
1030template <
typename T>
1032 if (special_dim == current_dim) {
1033 propagate_from_vertices_rec(special_dim, current_dim - 1, base);
1036 if (current_dim < 0) {
1037 std::size_t step = multipliers[special_dim];
1038 for(std::size_t i = 0; i < sizes[special_dim]; ++i) {
1039 std::size_t ref = base + step * 2 * i;
1040 data[ref + step] = std::max(data[ref], data[ref + 2 * step]);
1044 if (current_dim < special_dim)
1045 for(std::size_t i = 0; i < sizes[current_dim] + 1; ++i)
1046 propagate_from_vertices_rec(special_dim, current_dim - 1, base + multipliers[current_dim] * 2 * i);
1048 for(std::size_t i = 0; i < 2 * sizes[current_dim] + 1; ++i)
1049 propagate_from_vertices_rec(special_dim, current_dim - 1, base + multipliers[current_dim] * i);
1052template <
typename T>
1053bool compareFirstElementsOfTuples(
const std::pair<std::pair<T, std::size_t>,
char>& first,
1054 const std::pair<std::pair<T, std::size_t>,
char>& second) {
1055 if (first.first.first < second.first.first) {
1058 if (first.first.first > second.first.first) {
1062 return first.second < second.second;
1068namespace Cubical_complex = cubical_complex;
Iterator through top dimensional cells of the complex. The cells appear in order they are stored in t...
Definition: Bitmap_cubical_complex_base.h:315
Range corresponding to Top_dimensional_cells_iterator.
Definition: Bitmap_cubical_complex_base.h:410
Cubical complex represented as a bitmap, class with basic implementation.
Definition: Bitmap_cubical_complex_base.h:57
std::vector< std::size_t >::const_iterator Coboundary_iterator
Definition: Bitmap_cubical_complex_base.h:302
Bitmap_cubical_complex_base()
Definition: Bitmap_cubical_complex_base.h:64
void put_data_to_bins(std::size_t number_of_bins)
Definition: Bitmap_cubical_complex_base.h:613
void impose_lower_star_filtration()
Definition: Bitmap_cubical_complex_base.h:967
boost::counting_iterator< std::size_t > All_cells_iterator
Iterator through all cells in the complex (in order they appear in the structure – i....
Definition: Bitmap_cubical_complex_base.h:267
std::size_t size() const
Definition: Bitmap_cubical_complex_base.h:232
boost::iterator_range< All_cells_iterator > All_cells_range
Range corresponding to All_cells_iterator.
Definition: Bitmap_cubical_complex_base.h:282
virtual std::vector< std::size_t > get_coboundary_of_a_cell(std::size_t cell) const
Definition: Bitmap_cubical_complex_base.h:890
unsigned get_dimension_of_a_cell(std::size_t cell) const
Definition: Bitmap_cubical_complex_base.h:919
unsigned dimension() const
Definition: Bitmap_cubical_complex_base.h:227
Top_dimensional_cells_iterator top_dimensional_cells_iterator_begin()
Definition: Bitmap_cubical_complex_base.h:390
Top_dimensional_cells_range top_dimensional_cells_range()
Definition: Bitmap_cubical_complex_base.h:423
virtual std::vector< std::size_t > get_boundary_of_a_cell(std::size_t cell) const
Definition: Bitmap_cubical_complex_base.h:852
Coboundary_range coboundary_range(std::size_t sh)
Definition: Bitmap_cubical_complex_base.h:309
All_cells_range all_cells_range() const
Definition: Bitmap_cubical_complex_base.h:285
std::pair< T, T > min_max_filtration()
Definition: Bitmap_cubical_complex_base.h:648
Top_dimensional_cells_iterator top_dimensional_cells_iterator_end()
Definition: Bitmap_cubical_complex_base.h:398
std::vector< std::size_t >::const_iterator Boundary_iterator
Definition: Bitmap_cubical_complex_base.h:290
size_t get_top_dimensional_coface_of_a_cell(size_t splx)
Definition: Bitmap_cubical_complex_base.h:717
All_cells_iterator all_cells_iterator_end() const
Definition: Bitmap_cubical_complex_base.h:277
T & get_cell_data(std::size_t cell)
Definition: Bitmap_cubical_complex_base.h:962
void impose_lower_star_filtration_from_vertices()
Definition: Bitmap_cubical_complex_base.h:1024
Boundary_range boundary_range(std::size_t sh)
Definition: Bitmap_cubical_complex_base.h:297
virtual int compute_incidence_between_cells(std::size_t coface, std::size_t face) const
Definition: Bitmap_cubical_complex_base.h:157
size_t get_vertex_of_a_cell(size_t splx)
Definition: Bitmap_cubical_complex_base.h:730
All_cells_iterator all_cells_iterator_begin() const
Definition: Bitmap_cubical_complex_base.h:272
virtual ~Bitmap_cubical_complex_base()
Definition: Bitmap_cubical_complex_base.h:88