Loading...
Searching...
No Matches
matrix.h
Go to the documentation of this file.
1/* This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
2 * See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
3 * Author(s): Hannah Schreiber
4 *
5 * Copyright (C) 2022-24 Inria
6 *
7 * Modification(s):
8 * - YYYY/MM Author: Description of the modification
9 */
10
16#ifndef MASTER_MATRIX_H
17#define MASTER_MATRIX_H
18
19#include <type_traits>
20#include <vector>
21#include <unordered_map>
22#include <map>
23#include <initializer_list>
24
25#include <boost/intrusive/list.hpp>
26
27#include <gudhi/Debug_utils.h>
28
30
32
35
46
52
56
67
69namespace Gudhi {
71namespace persistence_matrix {
72
142template <class PersistenceMatrixOptions = Default_options<> >
143class Matrix {
144 public:
145 using Option_list = PersistenceMatrixOptions; //to make it accessible from the other classes
155 typename std::conditional<PersistenceMatrixOptions::is_z2,
158 >::type;
162 using element_type = typename Field_operators::element_type;
163 using characteristic_type = typename Field_operators::characteristic_type;
164
165 // TODO: move outside? unify with other bar types in Gudhi?
169 struct Bar {
170 Bar() : dim(-1), birth(-1), death(-1) {}
171
173
178 inline friend std::ostream &operator<<(std::ostream &stream, const Bar& bar) {
179 stream << "[" << bar.dim << "] ";
180 stream << bar.birth << ", " << bar.death;
181 stream << "\n";
182 return stream;
183 }
184 };
185
186 //tags for boost to associate a row and a column to a same cell
187 struct matrix_row_tag;
188 struct matrix_column_tag;
189
190 using base_hook_matrix_row =
191 boost::intrusive::list_base_hook<boost::intrusive::tag<matrix_row_tag>,
192 boost::intrusive::link_mode<boost::intrusive::auto_unlink> >;
193 using base_hook_matrix_list_column =
194 boost::intrusive::list_base_hook<boost::intrusive::tag<matrix_column_tag>,
195 boost::intrusive::link_mode<boost::intrusive::safe_link> >;
196 using base_hook_matrix_set_column =
197 boost::intrusive::set_base_hook<boost::intrusive::tag<matrix_column_tag>,
198 boost::intrusive::link_mode<boost::intrusive::safe_link> >;
199
200 //Two dummies are necessary to avoid double inheritance as a cell can inherit both a row and a column hook.
201 struct Dummy_row_hook {};
202 struct Dummy_column_hook {};
203
204 using row_hook_type = typename std::conditional<PersistenceMatrixOptions::has_row_access &&
206 base_hook_matrix_row,
207 Dummy_row_hook
208 >::type;
209 using column_hook_type = typename std::conditional<
211 base_hook_matrix_list_column,
213 base_hook_matrix_set_column,
214 Dummy_column_hook
215 >::type
216 >::type;
217
218 //Option to store the column index within the cell (additionnaly to the row index). Necessary only with row access.
219 using Cell_column_index_option =
220 typename std::conditional<PersistenceMatrixOptions::has_row_access,
221 Cell_column_index<index>,
222 Dummy_cell_column_index_mixin
223 >::type;
224 //Option to store the value of the cell.
225 //Unnecessary for values in Z_2 as there are always 1 (0-valued cells are never stored).
226 using Cell_field_element_option =
227 typename std::conditional<PersistenceMatrixOptions::is_z2,
228 Dummy_cell_field_element_mixin,
229 Cell_field_element<element_type>
230 >::type;
235
247
255 using cell_rep_type = typename std::conditional<PersistenceMatrixOptions::is_z2,
256 id_index,
257 std::pair<id_index, element_type>
258 >::type;
259
263 struct RowCellComp {
264 bool operator()(const Cell_type& c1, const Cell_type& c2) const {
265 return c1.get_column_index() < c2.get_column_index();
266 }
267 };
268
274 using Row_type =
275 typename std::conditional<PersistenceMatrixOptions::has_intrusive_rows,
276 boost::intrusive::list<Cell_type,
277 boost::intrusive::constant_time_size<false>,
278 boost::intrusive::base_hook<base_hook_matrix_row>
279 >,
280 std::set<Cell_type, RowCellComp>
281 >::type;
282
283 using row_container_type =
284 typename std::conditional<PersistenceMatrixOptions::has_removable_rows,
285 std::map<id_index, Row_type>,
286 std::vector<Row_type>
287 >::type;
288
289 //Row access at column level
290 using Row_access_option =
291 typename std::conditional<PersistenceMatrixOptions::has_row_access,
294 >::type;
295 //Row access at matrix level
296 using Matrix_row_access_option =
297 typename std::conditional<PersistenceMatrixOptions::has_row_access,
299 row_container_type,
301 id_index>,
303 >::type;
304
305 template <typename value_type>
306 using dictionnary_type =
308 std::unordered_map<unsigned int, value_type>,
309 std::vector<value_type>
310 >::type;
311
312 static const bool isNonBasic = PersistenceMatrixOptions::has_column_pairings ||
315
316 using Column_dimension_option =
317 typename std::conditional<isNonBasic,
320 >::type;
321 //Extra information needed for a column when the matrix is a @ref chainmatrix "chain matrix".
322 using Chain_column_option =
323 typename std::conditional<isNonBasic && !PersistenceMatrixOptions::is_of_boundary_type,
326 >::type;
327
336
342 using Column_type = typename std::conditional<
345 typename std::conditional<
348 typename std::conditional<
351 typename std::conditional<
354 typename std::conditional<
357 typename std::conditional<
360 typename std::conditional<
364 >::type
365 >::type
366 >::type
367 >::type
368 >::type
369 >::type
370 >::type;
371
372 struct Column_z2_settings{
373 Column_z2_settings() : cellConstructor() {}
374 Column_z2_settings([[maybe_unused]] characteristic_type characteristic) : cellConstructor() {}
375 Column_z2_settings(const Column_z2_settings& toCopy) : cellConstructor() {}
376
377 Cell_constructor cellConstructor; //will be replaced by more specific allocators depending on the column type.
378 };
379
380 struct Column_zp_settings {
381 Column_zp_settings() : operators(), cellConstructor() {}
382 //purposely triggers operators() instead of operators(characteristic) as the "dummy" values for the different
383 //operators can be different from -1.
384 Column_zp_settings(characteristic_type characteristic) : operators(), cellConstructor() {
385 if (characteristic != static_cast<characteristic_type>(-1)) operators.set_characteristic(characteristic);
386 }
387 Column_zp_settings(const Column_zp_settings& toCopy)
388 : operators(toCopy.operators.get_characteristic()), cellConstructor() {}
389
390 Field_operators operators;
391 Cell_constructor cellConstructor; //will be replaced by more specific allocators depending on the column type.
392 };
393
394 // struct Column_z2_with_rows_settings {
395 // Column_z2_with_rows_settings() : cellConstructor(), rows(nullptr) {}
396 // Column_z2_with_rows_settings([[maybe_unused]] characteristic_type characteristic)
397 // : cellConstructor(), rows(nullptr) {}
398
399 // Cell_constructor cellConstructor;
400 // row_container_type* rows;
401 // };
402
403 // struct Column_zp_with_rows_settings {
404 // Column_zp_with_rows_settings() : operators(), cellConstructor(), rows(nullptr) {}
405 // Column_zp_with_rows_settings(characteristic_type characteristic)
406 // : operators(characteristic), cellConstructor(), rows(nullptr) {}
407
408 // Field_operators operators;
409 // Cell_constructor cellConstructor;
410 // row_container_type* rows;
411 // };
412
413 //To prepare a more flexible use of the column types later (custom allocators depending on the column type etc.)
414 using Column_settings = typename std::conditional<
416 Column_z2_settings,
417 Column_zp_settings
418 >::type;
419
420 // using Column_settings = typename std::conditional<
421 // PersistenceMatrixOptions::is_z2,
422 // typename std::conditional<PersistenceMatrixOptions::has_row_access,
423 // Column_z2_with_rows_settings,
424 // Column_z2_settings
425 // >::type,
426 // typename std::conditional<PersistenceMatrixOptions::has_row_access,
427 // Column_zp_with_rows_settings,
428 // Column_zp_settings
429 // >::type
430 // >::type;
431
432 using column_container_type =
434 std::unordered_map<index, Column_type>,
435 std::vector<Column_type>
436 >::type;
437
444 typename std::conditional<hasFixedBarcode,
445 std::vector<Bar>,
446 typename std::conditional<PersistenceMatrixOptions::has_removable_columns,
447 std::list<Bar>,
448 std::vector<Bar>
449 >::type
450 >::type;
451 using bar_dictionnary_type =
452 typename std::conditional<hasFixedBarcode,
454 std::vector<index>, //RU
455 std::unordered_map<pos_index, index> //boundary
456 >::type,
457 typename std::conditional<PersistenceMatrixOptions::has_removable_columns,
458 std::unordered_map<pos_index, typename barcode_type::iterator>,
459 std::vector<index>
460 >::type
461 >::type;
462
463 //default type for boundaries to permit list initialization directly in function parameters
464 using boundary_type = typename std::conditional<PersistenceMatrixOptions::is_z2,
465 std::initializer_list<id_index>,
466 std::initializer_list<std::pair<id_index, element_type> >
467 >::type;
468
469 //i.e. is simple @ref boundarymatrix "boundary matrix". Also, only needed because of the reduction algorithm.
470 //TODO: remove the necessity and recalculate when needed or keep it like that?
471 static const bool maxDimensionIsNeeded =
474
475 using Matrix_dimension_option = typename std::conditional<
477 typename std::conditional<PersistenceMatrixOptions::has_removable_columns,
480 >::type,
482 >::type;
483
484 using Base_matrix_type =
485 typename std::conditional<PersistenceMatrixOptions::has_column_compression,
488 >::type;
492
493 template <class Base>
494 using Base_swap_option =
495 typename std::conditional<PersistenceMatrixOptions::has_vine_update ||
499 >::type;
500 using Base_pairing_option =
501 typename std::conditional<PersistenceMatrixOptions::has_column_pairings &&
506 >::type;
507
508 using RU_pairing_option =
509 typename std::conditional<PersistenceMatrixOptions::has_column_pairings &&
513 >::type;
514 using RU_vine_swap_option =
515 typename std::conditional<PersistenceMatrixOptions::has_vine_update,
518 >::type;
519 using RU_representative_cycles_option =
523 >::type;
524
525 using Chain_pairing_option =
526 typename std::conditional<PersistenceMatrixOptions::has_column_pairings &&
530 >::type;
531 using Chain_vine_swap_option = typename std::conditional<PersistenceMatrixOptions::has_vine_update,
534 >::type;
535 using Chain_representative_cycles_option =
539 >::type;
540
544 using cycle_type = std::vector<id_index>; //TODO: add coefficients
545
546 //Return types to factorize the corresponding methods
547
548 //The returned column is `const` if the matrix uses column compression
549 using returned_column_type =
550 typename std::conditional<!isNonBasic && PersistenceMatrixOptions::has_column_compression,
551 const Column_type,
553 >::type;
554 //The returned row is `const` if the matrix uses column compression
555 using returned_row_type =
556 typename std::conditional<!isNonBasic && PersistenceMatrixOptions::has_column_compression,
557 const Row_type,
559 >::type;
560 //If the matrix is a chain matrix, the insertion method returns the pivots of its unpaired columns used to reduce the
561 //inserted boundary. Otherwise, void.
562 using insertion_return_type =
563 typename std::conditional<PersistenceMatrixOptions::is_of_boundary_type || !isNonBasic ||
566 void,
567 std::vector<cell_rep_type>
568 >::type;
569
573 Matrix();
600 template <class Container_type = boundary_type>
601 Matrix(const std::vector<Container_type>& columns, characteristic_type characteristic = 11);
611 Matrix(int numberOfColumns, characteristic_type characteristic = static_cast<characteristic_type>(-1));
632 Matrix(const std::function<bool(pos_index,pos_index)>& birthComparator,
633 const std::function<bool(pos_index,pos_index)>& deathComparator);
658 template <class Boundary_type = boundary_type>
659 Matrix(const std::vector<Boundary_type>& orderedBoundaries,
660 const std::function<bool(pos_index,pos_index)>& birthComparator,
661 const std::function<bool(pos_index,pos_index)>& deathComparator,
662 characteristic_type characteristic = 11);
686 Matrix(unsigned int numberOfColumns,
687 const std::function<bool(pos_index,pos_index)>& birthComparator,
688 const std::function<bool(pos_index,pos_index)>& deathComparator,
689 characteristic_type characteristic = static_cast<characteristic_type>(-1));
695 Matrix(const Matrix& matrixToCopy);
702 Matrix(Matrix&& other) noexcept;
703
704 ~Matrix();
705
706 //TODO: compatibily with multi fields:
707 // - set_characteristic(characteristic_type min, characteristic_type max)
708 // - readapt reduction?
720 void set_characteristic(characteristic_type characteristic);
721
722 // (TODO: if there is no row access and the column type corresponds to the internal column type of the matrix,
723 // moving the column instead of copying it should be possible. Is it worth implementing it?)
734 template <class Container_type>
735 void insert_column(const Container_type& column);
747 template <class Container_type>
748 void insert_column(const Container_type& column, index columnIndex);
749 //TODO: for simple boundary matrices, add an index pointing to the first column inserted after the last call of
750 //get_current_barcode to enable several calls to get_current_barcode
782 template <class Boundary_type = boundary_type>
783 insertion_return_type insert_boundary(const Boundary_type& boundary, dimension_type dim = -1);
804 template <class Boundary_type>
805 insertion_return_type insert_boundary(id_index faceIndex, const Boundary_type& boundary, dimension_type dim = -1);
806
816 returned_column_type& get_column(index columnIndex);
824 const Column_type& get_column(index columnIndex) const;
825 //TODO: there is no particular reason that this method is not available for identifier indexing,
826 // just has to be added to the interface...
837 const Column_type& get_column(index columnIndex, bool inR);
838
839 //TODO: update column indices when reordering rows (after lazy swap) such that always MatIdx are returned.
850 returned_row_type& get_row(id_index rowIndex);
860 const Row_type& get_row(id_index rowIndex) const;
861 //TODO: there is no particular reason that this method is not available for identifier indexing,
862 // just has to be added to the interface...
873 const Row_type& get_row(id_index rowIndex, bool inR);
874
883 void remove_column(index columnIndex);
884 //TODO: rename method to be less confusing.
907 void erase_empty_row(id_index rowIndex);
908 //TODO: for chain matrices, replace IDIdx input with MatIdx input to homogenise.
927 void remove_maximal_face(index columnIndex);
928 //TODO: See if it would be better to use something more general than a vector for columnsToSwap, such that
929 // the user do not have to construct the vector from scratch. Like passing iterators instead. But it would be nice,
930 // to still be able to do (face, {})...
953 void remove_maximal_face(id_index faceIndex, const std::vector<id_index>& columnsToSwap);
970 void remove_last();
971
992 dimension_type get_column_dimension(index columnIndex) const;
993
1007 template <typename Index_type>
1008 std::enable_if_t<std::is_integral_v<Index_type> > add_to(Index_type sourceColumnIndex, Index_type targetColumnIndex);
1021 template <class Cell_range>
1022 std::enable_if_t<!std::is_integral_v<Cell_range> > add_to(const Cell_range& sourceColumn, index targetColumnIndex);
1023
1040 template <typename Index_type>
1041 std::enable_if_t<std::is_integral_v<Index_type> > multiply_target_and_add_to(Index_type sourceColumnIndex,
1042 int coefficient,
1043 Index_type targetColumnIndex);
1058 template <class Cell_range>
1059 std::enable_if_t<!std::is_integral_v<Cell_range> > multiply_target_and_add_to(const Cell_range& sourceColumn,
1060 int coefficient,
1061 index targetColumnIndex);
1062
1079 template <typename Index_type>
1080 std::enable_if_t<std::is_integral_v<Index_type> > multiply_source_and_add_to(int coefficient,
1081 Index_type sourceColumnIndex,
1082 Index_type targetColumnIndex);
1097 template <class Cell_range>
1098 std::enable_if_t<!std::is_integral_v<Cell_range> > multiply_source_and_add_to(int coefficient,
1099 const Cell_range& sourceColumn,
1100 index targetColumnIndex);
1101
1114 void zero_cell(index columnIndex, id_index rowIndex);
1124 void zero_cell(index columnIndex, id_index rowIndex, bool inR);
1136 void zero_column(index columnIndex);
1145 void zero_column(index columnIndex, bool inR);
1158 bool is_zero_cell(index columnIndex, id_index rowIndex);
1169 bool is_zero_cell(index columnIndex, id_index rowIndex, bool inR) const;
1183 bool is_zero_column(index columnIndex);
1195 bool is_zero_column(index columnIndex, bool inR);
1196
1209 index get_column_with_pivot(id_index faceIndex) const;
1217 id_index get_pivot(index columnIndex);
1218
1225 Matrix& operator=(Matrix other);
1232 friend void swap(Matrix& matrix1, Matrix& matrix2) {
1233 swap(matrix1.matrix_, matrix2.matrix_);
1234 std::swap(matrix1.colSettings_, matrix2.colSettings_);
1235 }
1236
1237 void print(); // for debug
1238
1239 //TODO: change the behaviour for boundary matrices.
1265 const barcode_type& get_current_barcode() const;
1266
1277 void swap_columns(index columnIndex1, index columnIndex2);
1288 void swap_rows(index rowIndex1, index rowIndex2);
1289 //TODO: find better name. And benchmark also to verify if it is really worth it to have this extra version in addition
1290 //to vine_swap.
1316 index vine_swap_with_z_eq_1_case(index columnIndex1, index columnIndex2);
1350 index vine_swap(index columnIndex1, index columnIndex2);
1351
1352 //TODO: Rethink the interface for representative cycles
1367 const std::vector<cycle_type>& get_representative_cycles();
1375 const cycle_type& get_representative_cycle(const Bar& bar);
1376
1377 private:
1378 using Matrix_type =
1379 typename std::conditional<
1380 isNonBasic,
1381 typename std::conditional<
1383 typename std::conditional<
1386 typename std::conditional<
1390 >::type,
1391 typename std::conditional<
1394 Boundary_matrix_type,
1396 >::type
1397 >::type,
1398 typename std::conditional<
1400 Chain_matrix_type,
1401 typename std::conditional<
1405 >::type
1406 >::type
1407 >::type,
1408 Base_matrix_type
1409 >::type;
1410
1411 // Field_operators* operators_;
1412 // Cell_constructor* cellPool_;
1413 Column_settings* colSettings_; //pointer because the of swap operator on matrix_ which also stores the pointer
1414 Matrix_type matrix_;
1415
1416 static constexpr void _assert_options();
1417};
1418
1419template <class PersistenceMatrixOptions>
1421 : colSettings_(new Column_settings()), matrix_(colSettings_)
1422{
1423 static_assert(
1426 "When no barcode is recorded with vine swaps, comparaison functions for the columns have to be provided.");
1427 _assert_options();
1428}
1429
1430template <class PersistenceMatrixOptions>
1431template <class Container_type>
1432inline Matrix<PersistenceMatrixOptions>::Matrix(const std::vector<Container_type>& columns,
1433 characteristic_type characteristic)
1434 : colSettings_(new Column_settings(characteristic)),
1435 matrix_(columns, colSettings_)
1436{
1439 "When no barcode is recorded with vine swaps for chain matrices, comparaison functions for the columns "
1440 "have to be provided.");
1441 _assert_options();
1442}
1443
1444template <class PersistenceMatrixOptions>
1445inline Matrix<PersistenceMatrixOptions>::Matrix(int numberOfColumns, characteristic_type characteristic)
1446 : colSettings_(new Column_settings(characteristic)),
1447 matrix_(numberOfColumns, colSettings_)
1448{
1451 "When no barcode is recorded with vine swaps for chain matrices, comparaison functions for the columns "
1452 "have to be provided.");
1453 _assert_options();
1454}
1455
1456template <class PersistenceMatrixOptions>
1457inline Matrix<PersistenceMatrixOptions>::Matrix(const std::function<bool(pos_index,pos_index)>& birthComparator,
1458 const std::function<bool(pos_index,pos_index)>& deathComparator)
1459 : colSettings_(new Column_settings()),
1460 matrix_(colSettings_, birthComparator, deathComparator)
1461{
1462 static_assert(
1465 "Constructor only available for chain matrices when vine swaps are enabled, but barcodes are not recorded.");
1466 _assert_options();
1467}
1468
1469template <class PersistenceMatrixOptions>
1470template <class Boundary_type>
1471inline Matrix<PersistenceMatrixOptions>::Matrix(const std::vector<Boundary_type>& orderedBoundaries,
1472 const std::function<bool(pos_index,pos_index)>& birthComparator,
1473 const std::function<bool(pos_index,pos_index)>& deathComparator,
1474 characteristic_type characteristic)
1475 : colSettings_(new Column_settings(characteristic)),
1476 matrix_(orderedBoundaries, colSettings_, birthComparator, deathComparator)
1477{
1478 static_assert(
1481 "Constructor only available for chain matrices when vine swaps are enabled, but barcodes are not recorded.");
1482 _assert_options();
1483}
1484
1485template <class PersistenceMatrixOptions>
1486inline Matrix<PersistenceMatrixOptions>::Matrix(unsigned int numberOfColumns,
1487 const std::function<bool(pos_index,pos_index)>& birthComparator,
1488 const std::function<bool(pos_index,pos_index)>& deathComparator,
1489 characteristic_type characteristic)
1490 : colSettings_(new Column_settings(characteristic)),
1491 matrix_(numberOfColumns, colSettings_, birthComparator, deathComparator)
1492{
1493 static_assert(
1496 "Constructor only available for chain matrices when vine swaps are enabled, but barcodes are not recorded.");
1497 _assert_options();
1498}
1499
1500template <class PersistenceMatrixOptions>
1502 : colSettings_(new Column_settings(*matrixToCopy.colSettings_)),
1503 matrix_(matrixToCopy.matrix_, colSettings_)
1504{
1505 _assert_options();
1506}
1507
1508template <class PersistenceMatrixOptions>
1510 : colSettings_(std::exchange(other.colSettings_, nullptr)),
1511 matrix_(std::move(other.matrix_))
1512{
1513 _assert_options();
1514}
1515
1516template <class PersistenceMatrixOptions>
1518{
1519 matrix_.reset(colSettings_);
1520 delete colSettings_;
1521}
1522
1523template <class PersistenceMatrixOptions>
1524inline void Matrix<PersistenceMatrixOptions>::set_characteristic(characteristic_type characteristic)
1525{
1526 if constexpr (!PersistenceMatrixOptions::is_z2) {
1527 if (colSettings_->operators.get_characteristic() != static_cast<characteristic_type>(-1)) {
1528 std::cerr << "Warning: Characteristic already initialised. Changing it could lead to incoherences in the matrice "
1529 "as the modulo was already applied to values in existing columns.";
1530 }
1531
1532 colSettings_->operators.set_characteristic(characteristic);
1533 }
1534}
1535
1536template <class PersistenceMatrixOptions>
1537template <class Container_type>
1538inline void Matrix<PersistenceMatrixOptions>::insert_column(const Container_type& column)
1539{
1540 if constexpr (!PersistenceMatrixOptions::is_z2){
1541 GUDHI_CHECK(colSettings_->operators.get_characteristic() != static_cast<characteristic_type>(-1),
1542 std::logic_error("Matrix::insert_column - Columns cannot be initialized if the coefficient field "
1543 "characteristic is not specified."));
1544 }
1545
1546 static_assert(
1547 !isNonBasic,
1548 "'insert_column' not available for the chosen options. The input has to be in the form of a face boundary.");
1549 matrix_.insert_column(column);
1550}
1551
1552template <class PersistenceMatrixOptions>
1553template <class Container_type>
1554inline void Matrix<PersistenceMatrixOptions>::insert_column(const Container_type& column, index columnIndex)
1555{
1556 if constexpr (!PersistenceMatrixOptions::is_z2){
1557 GUDHI_CHECK(colSettings_->operators.get_characteristic() != static_cast<characteristic_type>(-1),
1558 std::logic_error("Matrix::insert_column - Columns cannot be initialized if the coefficient field "
1559 "characteristic is not specified."));
1560 }
1561
1562 static_assert(!isNonBasic && !PersistenceMatrixOptions::has_column_compression,
1563 "'insert_column' with those parameters is not available for the chosen options.");
1565 "Columns have to be inserted at the end of the matrix when row access is enabled.");
1566 matrix_.insert_column(column, columnIndex);
1567}
1568
1569template <class PersistenceMatrixOptions>
1570template <class Boundary_type>
1571inline typename Matrix<PersistenceMatrixOptions>::insertion_return_type
1573{
1574 if constexpr (!PersistenceMatrixOptions::is_z2){
1575 GUDHI_CHECK(colSettings_->operators.get_characteristic() != static_cast<characteristic_type>(-1),
1576 std::logic_error("Matrix::insert_boundary - Columns cannot be initialized if the coefficient field "
1577 "characteristic is not specified."));
1578 }
1579
1580 if constexpr (isNonBasic && !PersistenceMatrixOptions::is_of_boundary_type &&
1582 return matrix_.insert_boundary(boundary, dim);
1583 else
1584 matrix_.insert_boundary(boundary, dim);
1585}
1586
1587template <class PersistenceMatrixOptions>
1588template <class Boundary_type>
1589inline typename Matrix<PersistenceMatrixOptions>::insertion_return_type
1591 const Boundary_type& boundary,
1592 dimension_type dim)
1593{
1594 if constexpr (!PersistenceMatrixOptions::is_z2){
1595 GUDHI_CHECK(colSettings_->operators.get_characteristic() != static_cast<characteristic_type>(-1),
1596 std::logic_error("Matrix::insert_boundary - Columns cannot be initialized if the coefficient field "
1597 "characteristic is not specified."));
1598 }
1599
1600 static_assert(isNonBasic, "Only enabled for non-basic matrices.");
1603 return matrix_.insert_boundary(faceIndex, boundary, dim);
1604 else
1605 matrix_.insert_boundary(faceIndex, boundary, dim);
1606}
1607
1608template <class PersistenceMatrixOptions>
1609inline typename Matrix<PersistenceMatrixOptions>::returned_column_type& Matrix<PersistenceMatrixOptions>::get_column(
1610 index columnIndex)
1611{
1612 return matrix_.get_column(columnIndex);
1613}
1614
1615template <class PersistenceMatrixOptions>
1617 index columnIndex) const
1618{
1619 return matrix_.get_column(columnIndex);
1620}
1621
1622template <class PersistenceMatrixOptions>
1624 index columnIndex, bool inR)
1625{
1626 // TODO: I don't think there is a particular reason why the indexation is forced, should be removed.
1627 static_assert(
1631 "Only enabled for position indexed RU matrices.");
1632
1633 return matrix_.get_column(columnIndex, inR);
1634}
1635
1636template <class PersistenceMatrixOptions>
1637inline typename Matrix<PersistenceMatrixOptions>::returned_row_type& Matrix<PersistenceMatrixOptions>::get_row(
1638 id_index rowIndex)
1639{
1640 static_assert(PersistenceMatrixOptions::has_row_access, "'get_row' is not available for the chosen options.");
1641
1642 return matrix_.get_row(rowIndex);
1643}
1644
1645template <class PersistenceMatrixOptions>
1647 id_index rowIndex) const
1648{
1649 static_assert(PersistenceMatrixOptions::has_row_access, "'get_row' is not available for the chosen options.");
1650
1651 return matrix_.get_row(rowIndex);
1652}
1653
1654template <class PersistenceMatrixOptions>
1656 id_index rowIndex, bool inR)
1657{
1658 static_assert(PersistenceMatrixOptions::has_row_access, "'get_row' is not available for the chosen options.");
1659 // TODO: I don't think there is a particular reason why the indexation is forced, should be removed.
1660 static_assert(
1664 "Only enabled for position indexed RU matrices.");
1665
1666 return matrix_.get_row(rowIndex, inR);
1667}
1668
1669template <class PersistenceMatrixOptions>
1671{
1672 static_assert(PersistenceMatrixOptions::has_map_column_container && !isNonBasic &&
1674 "'remove_column' is not available for the chosen options.");
1675
1676 matrix_.remove_column(columnIndex);
1677}
1678
1679template <class PersistenceMatrixOptions>
1681{
1682 static_assert(
1684 "'erase_empty_row' is not available for the chosen options.");
1685
1686 matrix_.erase_empty_row(rowIndex);
1687}
1688
1689template <class PersistenceMatrixOptions>
1691{
1693 "'remove_maximal_face(id_index)' is not available for the chosen options.");
1694 static_assert(isNonBasic && PersistenceMatrixOptions::has_vine_update,
1695 "'remove_maximal_face(id_index)' is not available for the chosen options.");
1698 "'remove_maximal_face(id_index)' is not available for the chosen options.");
1699
1700 matrix_.remove_maximal_face(columnIndex);
1701}
1702
1703template <class PersistenceMatrixOptions>
1705 const std::vector<id_index>& columnsToSwap)
1706{
1708 "'remove_maximal_face(id_index,const std::vector<index>&)' is not available for the chosen options.");
1709 static_assert(isNonBasic && !PersistenceMatrixOptions::is_of_boundary_type,
1710 "'remove_maximal_face(id_index,const std::vector<index>&)' is not available for the chosen options.");
1712 "'remove_maximal_face(id_index,const std::vector<index>&)' is not available for the chosen options.");
1713
1714 matrix_.remove_maximal_face(faceIndex, columnsToSwap);
1715}
1716
1717template <class PersistenceMatrixOptions>
1719{
1720 static_assert(PersistenceMatrixOptions::has_removable_columns || !isNonBasic,
1721 "'remove_last' is not available for the chosen options.");
1722 static_assert(!PersistenceMatrixOptions::has_column_compression || isNonBasic,
1723 "'remove_last' is not available for the chosen options.");
1724 static_assert(!isNonBasic || PersistenceMatrixOptions::is_of_boundary_type ||
1726 "'remove_last' is not available for the chosen options.");
1727
1728 matrix_.remove_last();
1729}
1730
1731template <class PersistenceMatrixOptions>
1733 const
1734{
1735 static_assert(isNonBasic, "'get_max_dimension' is not available for the chosen options.");
1736
1737 return matrix_.get_max_dimension();
1738}
1739
1740template <class PersistenceMatrixOptions>
1742{
1743 return matrix_.get_number_of_columns();
1744}
1745
1746template <class PersistenceMatrixOptions>
1748 index columnIndex) const
1749{
1750 static_assert(isNonBasic, "'get_column_dimension' is not available for the chosen options.");
1751
1752 return matrix_.get_column_dimension(columnIndex);
1753}
1754
1755template <class PersistenceMatrixOptions>
1756template <typename Index_type>
1757inline std::enable_if_t<std::is_integral_v<Index_type> > Matrix<PersistenceMatrixOptions>::add_to(
1758 Index_type sourceColumnIndex, Index_type targetColumnIndex)
1759{
1760 matrix_.add_to(sourceColumnIndex, targetColumnIndex);
1761}
1762
1763template <class PersistenceMatrixOptions>
1764template <class Cell_range>
1765inline std::enable_if_t<!std::is_integral_v<Cell_range> > Matrix<PersistenceMatrixOptions>::add_to(
1766 const Cell_range& sourceColumn, index targetColumnIndex)
1767{
1768 static_assert(!isNonBasic,
1769 "For boundary or chain matrices, only additions with columns inside the matrix is allowed to maintain "
1770 "algebraic consistency.");
1771
1772 matrix_.add_to(sourceColumn, targetColumnIndex);
1773}
1774
1775template <class PersistenceMatrixOptions>
1776template <typename Index_type>
1777inline std::enable_if_t<std::is_integral_v<Index_type> > Matrix<PersistenceMatrixOptions>::multiply_target_and_add_to(
1778 Index_type sourceColumnIndex, int coefficient, Index_type targetColumnIndex)
1779{
1780 if constexpr (PersistenceMatrixOptions::is_z2) {
1781 // coef will be converted to bool, because of element_type
1782 matrix_.multiply_target_and_add_to(sourceColumnIndex, coefficient % 2, targetColumnIndex);
1783 } else {
1784 matrix_.multiply_target_and_add_to(sourceColumnIndex, colSettings_->operators.get_value(coefficient), targetColumnIndex);
1785 }
1786}
1787
1788template <class PersistenceMatrixOptions>
1789template <class Cell_range>
1790inline std::enable_if_t<!std::is_integral_v<Cell_range> > Matrix<PersistenceMatrixOptions>::multiply_target_and_add_to(
1791 const Cell_range& sourceColumn, int coefficient, index targetColumnIndex)
1792{
1793 static_assert(!isNonBasic,
1794 "For boundary or chain matrices, only additions with columns inside the matrix is allowed to maintain "
1795 "algebraic consistency.");
1796
1797 if constexpr (PersistenceMatrixOptions::is_z2) {
1798 // coef will be converted to bool, because of element_type
1799 matrix_.multiply_target_and_add_to(sourceColumn, coefficient % 2, targetColumnIndex);
1800 } else {
1801 matrix_.multiply_target_and_add_to(sourceColumn, colSettings_->operators.get_value(coefficient), targetColumnIndex);
1802 }
1803}
1804
1805template <class PersistenceMatrixOptions>
1806template <typename Index_type>
1807inline std::enable_if_t<std::is_integral_v<Index_type> > Matrix<PersistenceMatrixOptions>::multiply_source_and_add_to(
1808 int coefficient, Index_type sourceColumnIndex, Index_type targetColumnIndex)
1809{
1810 if constexpr (PersistenceMatrixOptions::is_z2) {
1811 // coef will be converted to bool, because of element_type
1812 matrix_.multiply_source_and_add_to(coefficient % 2, sourceColumnIndex, targetColumnIndex);
1813 } else {
1814 matrix_.multiply_source_and_add_to(colSettings_->operators.get_value(coefficient), sourceColumnIndex, targetColumnIndex);
1815 }
1816}
1817
1818template <class PersistenceMatrixOptions>
1819template <class Cell_range>
1820inline std::enable_if_t<!std::is_integral_v<Cell_range> > Matrix<PersistenceMatrixOptions>::multiply_source_and_add_to(
1821 int coefficient, const Cell_range& sourceColumn, index targetColumnIndex)
1822{
1823 static_assert(!isNonBasic,
1824 "For boundary or chain matrices, only additions with columns inside the matrix is allowed to maintain "
1825 "algebraic consistency.");
1826
1827 if constexpr (PersistenceMatrixOptions::is_z2) {
1828 // coef will be converted to bool, because of element_type
1829 matrix_.multiply_source_and_add_to(coefficient % 2, sourceColumn, targetColumnIndex);
1830 } else {
1831 matrix_.multiply_source_and_add_to(colSettings_->operators.get_value(coefficient), sourceColumn, targetColumnIndex);
1832 }
1833}
1834
1835template <class PersistenceMatrixOptions>
1837{
1839 "'zero_cell' is not available for the chosen options.");
1840
1841 return matrix_.zero_cell(columnIndex, rowIndex);
1842}
1843
1844template <class PersistenceMatrixOptions>
1845inline void Matrix<PersistenceMatrixOptions>::zero_cell(index columnIndex, id_index rowIndex, bool inR)
1846{
1847 // TODO: I don't think there is a particular reason why the indexation is forced, should be removed.
1848 static_assert(
1852 "Only enabled for RU matrices.");
1853
1854 return matrix_.zero_cell(columnIndex, rowIndex, inR);
1855}
1856
1857template <class PersistenceMatrixOptions>
1859{
1861 "'zero_column' is not available for the chosen options.");
1862
1863 return matrix_.zero_column(columnIndex);
1864}
1865
1866template <class PersistenceMatrixOptions>
1867inline void Matrix<PersistenceMatrixOptions>::zero_column(index columnIndex, bool inR)
1868{
1869 // TODO: I don't think there is a particular reason why the indexation is forced, should be removed.
1870 static_assert(
1874 "Only enabled for RU matrices.");
1875
1876 return matrix_.zero_column(columnIndex, inR);
1877}
1878
1879template <class PersistenceMatrixOptions>
1881{
1882 return matrix_.is_zero_cell(columnIndex, rowIndex);
1883}
1884
1885template <class PersistenceMatrixOptions>
1886inline bool Matrix<PersistenceMatrixOptions>::is_zero_cell(index columnIndex, id_index rowIndex, bool inR) const
1887{
1888 // TODO: I don't think there is a particular reason why the indexation is forced, should be removed.
1889 static_assert(
1893 "Only enabled for RU matrices.");
1894
1895 return matrix_.is_zero_cell(columnIndex, rowIndex, inR);
1896}
1897
1898template <class PersistenceMatrixOptions>
1900{
1901 return matrix_.is_zero_column(columnIndex);
1902}
1903
1904template <class PersistenceMatrixOptions>
1906{
1907 // TODO: I don't think there is a particular reason why the indexation is forced, should be removed.
1908 static_assert(
1912 "Only enabled for RU matrices.");
1913
1914 return matrix_.is_zero_column(columnIndex, inR);
1915}
1916
1917template <class PersistenceMatrixOptions>
1919 id_index faceIndex) const
1920{
1921 static_assert(isNonBasic && (!PersistenceMatrixOptions::is_of_boundary_type ||
1924 "'get_column_with_pivot' is not available for the chosen options.");
1925
1926 return matrix_.get_column_with_pivot(faceIndex);
1927}
1928
1929template <class PersistenceMatrixOptions>
1931 index columnIndex)
1932{
1933 static_assert(isNonBasic, "'get_pivot' is not available for the chosen options.");
1934
1935 return matrix_.get_pivot(columnIndex);
1936}
1937
1938template <class PersistenceMatrixOptions>
1940{
1941 swap(matrix_, other.matrix_);
1942 std::swap(colSettings_, other.colSettings_);
1943
1944 return *this;
1945}
1946
1947template <class PersistenceMatrixOptions>
1949{
1950 return matrix_.print();
1951}
1952
1953template <class PersistenceMatrixOptions>
1956{
1957 static_assert(PersistenceMatrixOptions::has_column_pairings, "This method was not enabled.");
1958
1959 return matrix_.get_current_barcode();
1960}
1961
1962template <class PersistenceMatrixOptions>
1965{
1966 static_assert(PersistenceMatrixOptions::has_column_pairings, "This method was not enabled.");
1967 static_assert(
1970 "'get_current_barcode' is not const for boundary matrices as the barcode is only computed when explicitely "
1971 "asked.");
1972
1973 return matrix_.get_current_barcode();
1974}
1975
1976template <class PersistenceMatrixOptions>
1977inline void Matrix<PersistenceMatrixOptions>::swap_columns(index columnIndex1, index columnIndex2)
1978{
1979 static_assert(
1983 "This method was not enabled.");
1984 return matrix_.swap_columns(columnIndex1, columnIndex2);
1985}
1986
1987template <class PersistenceMatrixOptions>
1989{
1990 static_assert(
1994 "This method was not enabled.");
1995 return matrix_.swap_rows(rowIndex1, rowIndex2);
1996}
1997
1998template <class PersistenceMatrixOptions>
2008
2009template <class PersistenceMatrixOptions>
2011 index columnIndex1, index columnIndex2)
2012{
2013 static_assert(PersistenceMatrixOptions::has_vine_update, "This method was not enabled.");
2017 "This method was not enabled.");
2018
2019 return matrix_.vine_swap_with_z_eq_1_case(columnIndex1, columnIndex2);
2020}
2021
2022template <class PersistenceMatrixOptions>
2032
2033template <class PersistenceMatrixOptions>
2035 index columnIndex1, index columnIndex2)
2036{
2037 static_assert(PersistenceMatrixOptions::has_vine_update, "This method was not enabled.");
2041 "This method was not enabled.");
2042 return matrix_.vine_swap(columnIndex1, columnIndex2);
2043}
2044
2045template <class PersistenceMatrixOptions>
2047{
2048 static_assert(PersistenceMatrixOptions::can_retrieve_representative_cycles, "This method was not enabled.");
2049 matrix_.update_representative_cycles();
2050}
2051
2052template <class PersistenceMatrixOptions>
2053inline const std::vector<typename Matrix<PersistenceMatrixOptions>::cycle_type>&
2055{
2056 static_assert(PersistenceMatrixOptions::can_retrieve_representative_cycles, "This method was not enabled.");
2057 return matrix_.get_representative_cycles();
2058}
2059
2060template <class PersistenceMatrixOptions>
2063{
2064 static_assert(PersistenceMatrixOptions::can_retrieve_representative_cycles, "This method was not enabled.");
2065 return matrix_.get_representative_cycle(bar);
2066}
2067
2068template <class PersistenceMatrixOptions>
2070{
2071 static_assert(
2073 "Row access is not possible for heap columns.");
2075 "Vine update currently works only for Z_2 coefficients.");
2076 // static_assert(!PersistenceMatrixOptions::can_retrieve_representative_cycles || PersistenceMatrixOptions::is_z2,
2077 // "Representaive cycles can currently only be computed with Z_2 coefficients.");
2078 static_assert(
2080 "Column compression not compatible with heap columns.");
2081
2082 // // This should be warnings instead, as PersistenceMatrixOptions::has_column_compression is just ignored in those
2083 // // cases and don't produces errors as long as the corresponding methods are not called.
2084 // static_assert(!PersistenceMatrixOptions::has_column_compression || !PersistenceMatrixOptions::has_column_pairings,
2085 // "Column compression not available to compute persistence homology (it would bring no advantages; "
2086 // "use it for co-homology instead).");
2087 // static_assert(!PersistenceMatrixOptions::has_column_compression || !PersistenceMatrixOptions::has_vine_update,
2088 // "Column compression not available for vineyards.");
2089 // static_assert(!PersistenceMatrixOptions::has_column_compression ||
2090 // !PersistenceMatrixOptions::can_retrieve_representative_cycles,
2091 // "Column compression not available to retrieve representative cycles.");
2092 // // Would column removal while column compression be useful? If yes, should erase() remove a single column or the
2093 // // class of columns identical to the input?
2094 // // For a single column, I have an implementation for union-find (not the current one) which allows deleting a
2095 // // single element in constant time, but find becomes log n in worst case.
2096 // // For a column class, we either just ignore the removed class (constant time), but this results in memory
2097 // // residues, or, we have an erase method which is at least linear in the size of the class.
2098 // static_assert(
2099 // !PersistenceMatrixOptions::has_column_compression || !PersistenceMatrixOptions::has_map_column_container,
2100 // "When column compression is used, the removal of columns is not implemented yet.");
2101}
2102
2103} // namespace persistence_matrix
2104} // namespace Gudhi
2105
2106#endif // MASTER_MATRIX_H
Contains the Z2_field_operators class.
Contains the Base_matrix class.
Contains the Base_matrix_with_column_compression class.
Contains the Base_pairing class and Dummy_base_pairing structure.
Contains the Base_swap class and Dummy_base_swap structure.
Contains the Boundary_matrix class.
Contains the New_cell_constructor and Pool_cell_constructor structures.
Contains the Cell, Cell_column_index and Cell_field_element classes, as well as the Dummy_cell_column...
Contains the Chain_column_extra_properties class and Dummy_chain_properties structure.
Contains the Chain_matrix class.
Contains the Chain_pairing class and Dummy_chain_pairing structure.
Contains the Chain_representative_cycles class and Dummy_chain_representative_cycles structure.
Contains the Chain_barcode_swap and Chain_vine_swap classes, as well as the Dummy_chain_vine_swap and...
Class defining operators for the field.
Definition Z2_field_operators.h:32
A base matrix (also see Base_matrix), but with column compression. That is, all identical columns in ...
Definition base_matrix_with_column_compression.h:46
A basic matrix structure allowing to easily manipulate and access entire columns and rows,...
Definition base_matrix.h:39
Class managing the barcode for Boundary_matrix if the option was enabled.
Definition base_pairing.h:49
Class managing the column and row swaps in Base_matrix and Boundary_matrix.
Definition base_swap.h:48
Matrix structure to store the ordered boundary matrix of a filtered complex in order to compute its ...
Definition boundary_matrix.h:44
Matrix cell class. Stores by default only the row index it belongs to, but can also store its column ...
Definition cell_types.h:193
Class managing the pivot and partitioning of columns in Chain_matrix.
Definition chain_column_extra_properties.h:56
Matrix structure storing a compatible base of a filtered chain complex. See . The base is constructed...
Definition chain_matrix.h:50
Class managing the barcode for Chain_matrix if the option was enabled.
Definition chain_pairing.h:46
Class managing the representative cycles for Chain_matrix if the option was enabled.
Definition chain_rep_cycles.h:50
Class managing the vine swaps for Chain_matrix.
Definition chain_vine_swap.h:235
Column class following the PersistenceMatrixColumn concept. Not compatible with row access.
Definition heap_column.h:50
Overlay for non-basic matrices replacing all input and output MatIdx indices of the original methods ...
Definition overlay_ididx_to_matidx.h:42
Column class following the PersistenceMatrixColumn concept.
Definition intrusive_list_column.h:50
Column class following the PersistenceMatrixColumn concept.
Definition intrusive_set_column.h:51
Column class following the PersistenceMatrixColumn concept.
Definition list_column.h:51
Class managing the maximal dimension of a face represented in the inheritating matrix,...
Definition matrix_dimension_holders.h:115
Class managing the maximal dimension of a face represented in the inheritating matrix,...
Definition matrix_dimension_holders.h:53
Class managing the row access for the inheritating matrix.
Definition matrix_row_access.h:52
Data structure for matrices, and in particular thought for matrices representing filtered complexes i...
Definition matrix.h:143
bool is_zero_cell(index columnIndex, id_index rowIndex)
Indicates if the cell at given coordinates has value zero.
Definition matrix.h:1880
const cycle_type & get_representative_cycle(const Bar &bar)
Only available if PersistenceMatrixOptions::can_retrieve_representative_cycles is true....
Definition matrix.h:2062
void zero_cell(index columnIndex, id_index rowIndex)
Zeroes the cell at the given coordinates. Not available for chain matrices and for base matrices with...
Definition matrix.h:1836
bool is_zero_column(index columnIndex)
Indicates if the column at given index has value zero.
Definition matrix.h:1899
bool vine_swap(pos_index index)
Only available if PersistenceMatrixOptions::has_vine_update is true and if it is either a boundary ma...
Definition matrix.h:2023
returned_column_type & get_column(index columnIndex)
Returns the column at the given MatIdx index. For RU matrices, is equivalent to get_column(columnInde...
Definition matrix.h:1609
void erase_empty_row(id_index rowIndex)
The effect varies depending on the matrices and the options:
Definition matrix.h:1680
const std::vector< cycle_type > & get_representative_cycles()
Only available if PersistenceMatrixOptions::can_retrieve_representative_cycles is true....
Definition matrix.h:2054
std::vector< id_index > cycle_type
Type of a representative cycle. Vector of row indices.
Definition matrix.h:544
void swap_rows(index rowIndex1, index rowIndex2)
Only available for base matrices without column compression and simple boundary matrices (only storin...
Definition matrix.h:1988
id_index get_pivot(index columnIndex)
Returns the row index of the pivot of the given column. Only available for non-basic matrices.
Definition matrix.h:1930
void remove_maximal_face(index columnIndex)
Only available for RU and chain matrices and if PersistenceMatrixOptions::has_removable_columns and P...
Definition matrix.h:1690
typename PersistenceMatrixOptions::index_type pos_index
Definition matrix.h:148
dimension_type get_max_dimension() const
Returns the maximal dimension of a face stored in the matrix. Only available for non-basic matrices a...
Definition matrix.h:1732
typename std::conditional< PersistenceMatrixOptions::has_intrusive_rows, boost::intrusive::list< Cell_type, boost::intrusive::constant_time_size< false >, boost::intrusive::base_hook< base_hook_matrix_row > >, std::set< Cell_type, RowCellComp > >::type Row_type
Type of the rows stored in the matrix. Is either an intrusive list of Cell_type (not ordered) if Pers...
Definition matrix.h:281
typename std::conditional< hasFixedBarcode, std::vector< Bar >, typename std::conditional< PersistenceMatrixOptions::has_removable_columns, std::list< Bar >, std::vector< Bar > >::type >::type barcode_type
Type of the computed barcode. It is either a list of Matrix::Bar or a vector of Matrix::Bar,...
Definition matrix.h:450
returned_row_type & get_row(id_index rowIndex)
Only available if PersistenceMatrixOptions::has_row_access is true. Returns the row at the given row ...
Definition matrix.h:1637
dimension_type get_column_dimension(index columnIndex) const
Returns the dimension of the given face. Only available for non-basic matrices.
Definition matrix.h:1747
typename std::conditional< PersistenceMatrixOptions::column_type==Column_types::HEAP, Heap_column_type, typename std::conditional< PersistenceMatrixOptions::column_type==Column_types::LIST, List_column_type, typename std::conditional< PersistenceMatrixOptions::column_type==Column_types::SET, Set_column_type, typename std::conditional< PersistenceMatrixOptions::column_type==Column_types::UNORDERED_SET, Unordered_set_column_type, typename std::conditional< PersistenceMatrixOptions::column_type==Column_types::VECTOR, Vector_column_type, typename std::conditional< PersistenceMatrixOptions::column_type==Column_types::INTRUSIVE_LIST, Intrusive_list_column_type, typename std::conditional< PersistenceMatrixOptions::column_type==Column_types::NAIVE_VECTOR, Naive_vector_column_type, Intrusive_set_column_type >::type >::type >::type >::type >::type >::type >::type Column_type
Type of the columns stored in the matrix. The type depends on the value of PersistenceMatrixOptions::...
Definition matrix.h:370
typename PersistenceMatrixOptions::index_type index
Definition matrix.h:146
std::enable_if_t< std::is_integral_v< Index_type > > add_to(Index_type sourceColumnIndex, Index_type targetColumnIndex)
Adds column at sourceColumnIndex onto the column at targetColumnIndex in the matrix....
Definition matrix.h:1757
insertion_return_type insert_boundary(const Boundary_type &boundary, dimension_type dim=-1)
Inserts at the end of the matrix a new ordered column corresponding to the given boundary....
Definition matrix.h:1572
std::enable_if_t< std::is_integral_v< Index_type > > multiply_target_and_add_to(Index_type sourceColumnIndex, int coefficient, Index_type targetColumnIndex)
Multiplies the target column with the coefficient and then adds the source column to it....
Definition matrix.h:1777
bool vine_swap_with_z_eq_1_case(pos_index index)
Only available if PersistenceMatrixOptions::has_vine_update is true and if it is either a bounary mat...
Definition matrix.h:1999
void insert_column(const Container_type &column)
Inserts a new ordered column at the end of the matrix by copying the given range of cell_rep_type....
Definition matrix.h:1538
const barcode_type & get_current_barcode()
Returns the current barcode of the matrix. Available only if PersistenceMatrixOptions::has_column_pai...
Definition matrix.h:1955
void set_characteristic(characteristic_type characteristic)
Sets the characteristic of the coefficient field if PersistenceMatrixOptions::is_z2 is false,...
Definition matrix.h:1524
void remove_last()
Removes the last inserted column/face from the matrix. If the matrix is non basic,...
Definition matrix.h:1718
static New_cell_constructor< Cell_type > defaultCellConstructor
Default cell constructor/destructor, using classic new and delete. For now, only used as default valu...
Definition matrix.h:241
Pool_cell_constructor< Cell_type > Cell_constructor
Cell constructor/destructor used by the matrix. Uses a pool of cells to accelerate memory management,...
Definition matrix.h:246
Matrix()
Default constructor. Initializes an empty matrix.
Definition matrix.h:1420
void zero_column(index columnIndex)
Zeroes the column at the given index. Not available for chain matrices and for base matrices with col...
Definition matrix.h:1858
index get_column_with_pivot(id_index faceIndex) const
Returns the MatIdx index of the column which has the given row index as pivot. Only available for RU ...
Definition matrix.h:1918
typename PersistenceMatrixOptions::index_type id_index
Definition matrix.h:147
void remove_column(index columnIndex)
Only available for base matrices without column compression and if PersistenceMatrixOptions::has_map_...
Definition matrix.h:1670
Matrix & operator=(Matrix other)
Assign operator.
Definition matrix.h:1939
std::enable_if_t< std::is_integral_v< Index_type > > multiply_source_and_add_to(int coefficient, Index_type sourceColumnIndex, Index_type targetColumnIndex)
Multiplies the source column with the coefficient before adding it to the target column....
Definition matrix.h:1807
friend void swap(Matrix &matrix1, Matrix &matrix2)
Swap operator for two matrices.
Definition matrix.h:1232
index get_number_of_columns() const
Returns the current number of columns in the matrix.
Definition matrix.h:1741
Cell< Matrix< PersistenceMatrixOptions > > Cell_type
Type of a matrix cell. See Cell for a more detailed description.
Definition matrix.h:234
typename std::conditional< PersistenceMatrixOptions::is_z2, Gudhi::persistence_fields::Z2_field_operators, typename PersistenceMatrixOptions::Field_coeff_operators >::type Field_operators
Coefficiants field type.
Definition matrix.h:158
typename PersistenceMatrixOptions::dimension_type dimension_type
Definition matrix.h:149
typename Field_operators::element_type element_type
Type of a field element.
Definition matrix.h:162
void update_representative_cycles()
Only available if PersistenceMatrixOptions::can_retrieve_representative_cycles is true....
Definition matrix.h:2046
typename std::conditional< PersistenceMatrixOptions::is_z2, id_index, std::pair< id_index, element_type > >::type cell_rep_type
Type used to identify a cell, for exemple when inserting a boundary. If PersistenceMatrixOptions::is_...
Definition matrix.h:258
void swap_columns(index columnIndex1, index columnIndex2)
Only available for base matrices without column compression and simple boundary matrices (only storin...
Definition matrix.h:1977
Column class following the PersistenceMatrixColumn concept.
Definition naive_vector_column.h:51
Overlay for chain matrices replacing all input and output MatIdx indices of the original methods with...
Definition overlay_posidx_to_matidx.h:40
Matrix structure to store the ordered boundary matrix of a filtered complex in order to compute its ...
Definition ru_matrix.h:42
Class managing the barcode for RU_matrix if the option was enabled.
Definition ru_pairing.h:46
Class managing the representative cycles for RU_matrix if the option was enabled.
Definition ru_rep_cycles.h:50
Class managing the vine swaps for RU_matrix.
Definition ru_vine_swap.h:65
Class managing the row access for the columns.
Definition row_access.h:50
Column class following the PersistenceMatrixColumn concept.
Definition set_column.h:51
Column class following the PersistenceMatrixColumn concept.
Definition unordered_set_column.h:67
Column class following the PersistenceMatrixColumn concept.
Definition vector_column.h:53
Contains the Column_dimension_holder class and Dummy_dimension_holder structure.
@ POSITION
Definition persistence_matrix_options.h:51
@ CONTAINER
Definition persistence_matrix_options.h:50
@ IDENTIFIER
Definition persistence_matrix_options.h:52
@ INTRUSIVE_LIST
Definition persistence_matrix_options.h:39
@ INTRUSIVE_SET
Definition persistence_matrix_options.h:40
@ UNORDERED_SET
Definition persistence_matrix_options.h:38
@ LIST
Definition persistence_matrix_options.h:31
@ SET
Definition persistence_matrix_options.h:32
@ NAIVE_VECTOR
Definition persistence_matrix_options.h:37
@ VECTOR
Definition persistence_matrix_options.h:35
@ HEAP
Definition persistence_matrix_options.h:33
Contains the Heap_column class. Also defines the std::hash method for Heap_column.
Contains the Intrusive_list_column class. Also defines the std::hash method for Intrusive_list_column...
Contains the Intrusive_set_column class. Also defines the std::hash method for Intrusive_set_column.
Contains the List_column class. Also defines the std::hash method for List_column.
Contains the Matrix_max_dimension_holder Matrix_all_dimension_holder classes and the Dummy_matrix_dim...
Contains the Matrix_row_access class and Dummy_matrix_row_access structure.
Contains the Naive_vector_column class. Also defines the std::hash method for Naive_vector_column.
Gudhi namespace.
Definition SimplicialComplexForAlpha.h:14
Contains the Id_to_index_overlay class.
Contains the Position_to_index_overlay class.
Contains the options for the matrix template.
Contains the Row_access class and Dummy_row_access structure.
Contains the RU_matrix class.
Contains the RU_pairing class and Dummy_ru_pairing structure.
Contains the RU_representative_cycles class and Dummy_ru_representative_cycles structure.
Contains the RU_vine_swap class, as well as the Dummy_ru_vine_swap and Dummy_ru_vine_pairing structur...
Contains the Set_column class. Also defines the std::hash method for Set_column.
Class managing the dimension access of a column.
Definition column_dimension_holder.h:50
Empty structure. Inheritated instead of Base_pairing, when the computation of the barcode was not ena...
Definition base_pairing.h:35
Empty structure. Inheritated instead of Base_swap, when the column and row swaps are not enabled.
Definition base_swap.h:32
Empty structure. Inheritated instead of Chain_pairing, when the computation of the barcode was not en...
Definition chain_pairing.h:32
Empty structure. Inheritated instead of Chain_column_extra_properties, when the columns are not meant...
Definition chain_column_extra_properties.h:33
Empty structure. Inheritated instead of Chain_representative_cycles, when the computation of the repr...
Definition chain_rep_cycles.h:34
Empty structure. Inheritated instead of Chain_vine_swap, when vine swappes are not enabled.
Definition chain_vine_swap.h:53
Empty structure. Inheritated instead of Column_dimension_holder, when the columns are not storing a d...
Definition column_dimension_holder.h:32
Empty structure. Inheritated instead of Matrix_max_dimension_holder or Matrix_all_dimension_holder,...
Definition matrix_dimension_holders.h:34
Empty structure. Inheritated instead of Matrix_row_access, when the the row access is not enabled.
Definition matrix_row_access.h:31
Empty structure. Inheritated instead of Row_access, if the row access is not enabled.
Definition row_access.h:32
Empty structure. Inheritated instead of RU_pairing, when the computation of the barcode was not enabl...
Definition ru_pairing.h:32
Empty structure. Inheritated instead of RU_representative_cycles, when the computation of the represe...
Definition ru_rep_cycles.h:34
Empty structure. Inheritated instead of RU_vine_swap, when vine swappes are not enabled.
Definition ru_vine_swap.h:38
Type for a bar in the computed barcode. Stores the birth, death and dimension of the bar.
Definition matrix.h:169
dimension_type dim
Definition matrix.h:174
pos_index birth
Definition matrix.h:175
pos_index death
Definition matrix.h:176
Compaires two cells by their position in the row. They are assume to be in the same row.
Definition matrix.h:263
Cell factory. Constructs and destroyes cell pointers with new and delete.
Definition cell_constructors.h:36
Concept of the template parameter for the class Matrix.
Definition PersistenceMatrixOptions.h:32
unspecified dimension_type
Type for the dimension. Has to be an integer type. If unsigned, the maximal value of the type should ...
Definition PersistenceMatrixOptions.h:42
static const Column_indexation_types column_indexation_type
Specifies the desired indexation scheme to access the methods of the matrix. See matrix description a...
Definition PersistenceMatrixOptions.h:66
static const Column_types column_type
Specifies the desired column type. All possible column types are described in Column_types.
Definition PersistenceMatrixOptions.h:60
unspecified index_type
Type for the different indexation types and should be able to contain the maximal number of columns o...
Definition PersistenceMatrixOptions.h:48
static const bool has_matrix_maximal_dimension_access
Only enabled for boundary and chain matrices, i.e., when at least one of the following is true: has_c...
Definition PersistenceMatrixOptions.h:142
static const bool has_map_column_container
If set to true, the underlying container containing the matrix columns is an std::unordered_map....
Definition PersistenceMatrixOptions.h:101
static const bool has_column_compression
Only enabled for base matrices (i.e., none of the following is true: has_column_pairings,...
Definition PersistenceMatrixOptions.h:83
static const bool has_row_access
If set to true, enables the method Matrix::get_row.
Definition PersistenceMatrixOptions.h:111
static const bool can_retrieve_representative_cycles
If set to true, enables the methods Matrix::update_representative_cycles and Matrix::get_representati...
Definition PersistenceMatrixOptions.h:161
static const bool has_removable_rows
Only enabled if has_row_access is true, ignored otherwise. If set to true, the underlying container c...
Definition PersistenceMatrixOptions.h:124
static const bool has_column_and_row_swaps
Only enabled for base matrices or simple boundary matrices, i.e., when both has_vine_update and can_r...
Definition PersistenceMatrixOptions.h:89
static const bool is_z2
If true, indicates that the values contained in the matrix are in and can therefore be treated like ...
Definition PersistenceMatrixOptions.h:56
static const bool has_column_pairings
If set to true, enables the method Matrix::get_current_barcode. The matrix will then either be a boun...
Definition PersistenceMatrixOptions.h:148
unspecified Field_coeff_operators
Field operators. Has to follow the FieldOperators concept. The type will not be used if is_z2 is set ...
Definition PersistenceMatrixOptions.h:37
static const bool has_vine_update
If set to true, enables the methods Matrix::vine_swap and Matrix::vine_swap_with_z_eq_1_case....
Definition PersistenceMatrixOptions.h:154
static const bool is_of_boundary_type
Only used, when at least one of the following is true: has_column_pairings, has_vine_update or can_re...
Definition PersistenceMatrixOptions.h:132
static const bool has_removable_columns
If set to true, enables the methods Matrix::remove_maximal_face and Matrix::remove_last,...
Definition PersistenceMatrixOptions.h:106
static const bool has_intrusive_rows
Only enabled if has_row_access is true, ignored otherwise. If set to true, the underlying container r...
Definition PersistenceMatrixOptions.h:117
Contains the Unordered_set_column class. Also defines the std::hash method for Unordered_set_column.
Contains the Vector_column class. Also defines the std::hash method for Vector_column.