This file contains the definition of two-layer cubical sets, as introduced in the paper "Excision-preserving cubical approach to the algorithmic computation of the discrete Conley index" by Kinga Stolot and Pawel Pilarczyk. More...
#include "chomp/cubes/cube.h"#include "chomp/cubes/cell.h"#include "chomp/cubes/neighbor.h"#include "chomp/cubes/cubmaps.h"#include "chomp/struct/bitfield.h"#include "chomp/system/textfile.h"#include <iostream>#include <fstream>#include <cstdlib>#include <cstring>#include <exception>Go to the source code of this file.
Classes | |
| class | chomp::homology::tCube2l< tCube > |
| A (hyper)cube with additional information about the layer number. More... | |
| class | chomp::homology::tCell2l< tCell > |
| A general cubical cell with additional information about the layer number. More... | |
Namespaces | |
| namespace | chomp |
This namespace contains the entire CHomP library interface. | |
| namespace | chomp::homology |
This namespace contains the core of the homology computation procedures and related classes and templates contained in the CHomP C++ library. | |
Typedefs | |
| typedef short int | chomp::homology::theLayerType |
| The type of the layer variable. | |
| typedef tCube2l< tCubeBase < coordinate > > | chomp::homology::Cube2l |
| A typical full cube in the two-layer setting. | |
| typedef tCell2l< tCellBase < coordinate > > | chomp::homology::CubicalCell2l |
| A typical cubical cell in the two-layer setting. | |
| typedef mvmap< Cube2l, Cube2l > | chomp::homology::CombinatorialMultivaluedMap2l |
| A typical multivalued map on full cubes in the two-layer setting. | |
| typedef hashedset< Cube2l > | chomp::homology::SetOfCubes2l |
| A typical set of full cubes in the two-layer setting. | |
| typedef hashedset< CubicalCell2l > | chomp::homology::SetOfCubicalCells2l |
| A typical set of cubical cells in the two-layer setting. | |
| typedef gcomplex < CubicalCell2l, integer > | chomp::homology::CubicalComplex2l |
| A typical cubical complex in the two-layer setting. | |
| typedef mvcellmap < CubicalCell2l, integer, CubicalCell2l > | chomp::homology::CubicalMultivaluedMap2l |
| A typical multivalued cubical-cellular map in the two-layer setting. | |
Functions | |
| template<class tCube > | |
| int | chomp::homology::operator== (const tCube2l< tCube > &c1, const tCube2l< tCube > &c2) |
| The operator == verifies if two cubes are equal. | |
| template<class tCube > | |
| int | chomp::homology::operator!= (const tCube2l< tCube > &c1, const tCube2l< tCube > &c2) |
| The operator != verifies whether two cubes are different. | |
| template<class tCube > | |
| tCube2l< tCube > | chomp::homology::operator* (const tCube2l< tCube > &c1, const tCube2l< tCube > &c2) |
| The operator * computes the Cartesian product of two cubes. | |
| template<class tCube > | |
| std::ostream & | chomp::homology::operator<< (std::ostream &out, const tCube2l< tCube > &c) |
| The operator << writes a cube to the output stream in the text mode. | |
| template<class tCube > | |
| std::istream & | chomp::homology::operator>> (std::istream &in, tCube2l< tCube > &c) |
| The operator >> reads a cube from the input stream in the text mode. | |
| template<class tCube > | |
| std::istream & | chomp::homology::operator>> (std::istream &in, hashedset< tCube2l< tCube > > &s) |
| A specialized version of the operator >> for reading a set of cubes and ignores the first line "dimension N". | |
| template<class tCube > | |
| std::istream & | chomp::homology::operator>> (std::istream &in, mvmap< tCube2l< tCube >, tCube2l< tCube > > &m) |
| A specialized version of the operator >> that reads a combinatorial cubical multivalued map. | |
| template<class tCell > | |
| int | chomp::homology::operator== (const tCell2l< tCell > &c1, const tCell2l< tCell > &c2) |
| The operator == verifies if two cells are equal. | |
| template<class tCell > | |
| int | chomp::homology::operator!= (const tCell2l< tCell > &c1, const tCell2l< tCell > &c2) |
| The operator != verifies whether two cubes are different. | |
| template<class tCell > | |
| tCell2l< tCell > | chomp::homology::operator* (const tCell2l< tCell > &c1, const tCell2l< tCell > &c2) |
| The operator * computes the Cartesian product of two cells. | |
| template<class tCell > | |
| std::ostream & | chomp::homology::operator<< (std::ostream &out, const tCell2l< tCell > &c) |
| The operator << writes a cubical cell to the text output stream. | |
| template<class tCell > | |
| std::istream & | chomp::homology::operator>> (std::istream &in, tCell2l< tCell > &c) |
| The operator >> reads a cubical cell from the text input stream. | |
| template<class tCell > | |
| tCell2l< tCell > | chomp::homology::boundarycell (const tCell2l< tCell > &q, int i, bool onlyexisting) |
| Computes the given boundary element of a cell. | |
| template<class tCell > | |
| tCell2l< tCell > | chomp::homology::boundarycell (const tCell2l< tCell > &q, int i) |
| Computes the given boundary element of a cell. | |
| template<class tCell > | |
| int | chomp::homology::boundarylength (const tCell2l< tCell > &q) |
| Returns the length of the boundary of a cell. | |
| template<class tCell > | |
| int | chomp::homology::boundarycoef (const tCell2l< tCell > &q, int i) |
| Returns the given coefficient in the boundary of a cell. | |
| template<class tCube > | |
| tCube2l< tCube > | chomp::homology::bit2neighbor (const tCube2l< tCube > &q, int_t number, bool unconditional=false) |
| Specialization of the "bit2neighbor" function for two-layer cubes. | |
| template<class tCube > | |
| int_t | chomp::homology::neighbor2bit (const tCube2l< tCube > &q, const tCube2l< tCube > &neighbor) |
| Specialization of the "neighbor2bit" function for two-layer cubes. | |
| template<class tCube > | |
| bool | chomp::homology::intersection2l (const tCube &q0, const tCube &q1, BitField *bits) |
| Computes the intersection between two cubes at different layers. | |
| template<class tCube , class tCubeSet1 , class tCubeSet2 > | |
| int_t | chomp::homology::getneighbors_scan (const tCube2l< tCube > &q2l, BitField *bits, const tCubeSet1 &theset, tCubeSet2 *neighbors, int_t limit) |
| Specialization of the function which gets neighbors of the given cube by scanning the entire set of possible neighbors. | |
| template<class tCube , class tCubeSet1 , class tCubeSet2 > | |
| int_t | chomp::homology::getneighbors_generate (const tCube2l< tCube > &q2l, BitField *bits, const tCubeSet1 &theset, tCubeSet2 *neighbors, int_t limit) |
| Specialization of the function which gets neighbors of the given cube by generating all the possible neighbors and checking if they are present in the given set. | |
| template<class euclidom , class tCell , class tCube > | |
| int_t | chomp::homology::createimages (mvcellmap< tCell2l< tCell >, euclidom, tCube2l< tCube > > &m, const mvmap< tCube2l< tCube >, tCube2l< tCube > > &f1, const mvmap< tCube2l< tCube >, tCube2l< tCube > > &f2, const hashedset< tCube2l< tCube > > &dom1, const hashedset< tCube2l< tCube > > &dom2) |
| Specialization of the "createimages" function for two-layer cubes. | |
This file contains the definition of two-layer cubical sets, as introduced in the paper "Excision-preserving cubical approach to the algorithmic computation of the discrete Conley index" by Kinga Stolot and Pawel Pilarczyk.
In addition to the classes that implement the idea of two-layer full cubes and elementary cubes, specializations of some operations used in the homology computation software are also implemented. See the program "homcub2l.cpp" for a sample application of the two-layer cubical sets defined in this header file
Definition in file twolayer.h.
1.7.1