Basic Applied Topology Subprograms¶
The Basic Applied Topology Subprograms (BATS) are a C++ header-only library for applied algebraic topology. It includes functionality for
Creation of simplicial, cubical, and cell complexes, as well as cellular maps
Implementation of chain and homology functors
Filtered complexes and persistent homology
Diagrams of spaces and maps, and computation of zigzag homology
Topological constructions such as Vietoris-Rips complexes, Witness complexes, Nerves of covers
Sparse linear algebra over (finite) fields
And more!
BATS attempts to balance performance with extensibility. The library uses template metaprogramming to make it easy to swap in and out different constructions while maintaining a consistent core functionality.
Why BATS?¶
There are many very high-performance libraries for computing things like persistent homology that have been developed over the past decade. Unlike many of these libraries BATS is focused on functorality, and provides functionality to handle maps between topological spaces, chain maps, and induced maps on homology. The goal is to make it easier for researchers and practitioners to implement and explore the vast back catalog of algebraic topology while also providing applied functionality.
Installation¶
You can obtain BATS from GitHub:
$ git clone https://github.com/bnels/BATS.git
Dependencies¶
BATS is written in C++ and requires a compiler which is able to understand C++17 syntax. It has been run and tested on Linux (Ubuntu and Fedora distributions) using the gcc compiler.
BATS itself is header-only, and is built using STL data structures, meaning you don’t need to find other headers.
To get the most out of BATS, you should compile with OpenMP.
$ g++ ...<other flags> -std=c++17 -fopenmp
Testing Installation¶
Once you have BATS on your computer, you can test your installation. from the root of your repository:
$ cd tests
$ make test -j
Quick Start Guide¶
This guide will cover several basic use cases for BATS. More specialized functionality is covered in the tutorials and examples. Ultimately, you can use the API reference.
Simplicial Complexes and Homology¶
BATS offers two implementations of simplicial complexes: SimplicialComplex
and LightSimplicialComplex. While the interenal representations differ, they
both have the same interface which can be used. When dealing with stand-alone
simplices, BATS uses std::vector<size_t>
to represent simplices, from which
the vertex set and dimension of the simplex can be extracted.
Warning
Simplices in bats should generally be assumed to be ordered, meaning that
{0,1,2}
is not the same as {1,2,0}
. If you want to use
unordered simplices, you can either add vertices in sorted order, or use
a sorting algorithm before adding simplices to complexes.
The two main methods for adding simplices to simplicial complexes are add
,
which assumes you have already added the boundary of a simplex, and add_recursive
which will add any faces that are not already present.
bats::SimplcialComplex X();
X.add_recursive({0,1,2});
X.add_recursive({2,3});
X.add({1,3});
X.print_summary();
The above code will create a SimplicialComplex with a single connected component
and a single hole. The call to X.print_summary()
will produce
SimplicialComplex, maxdim = 2
dim 0 : 4 cells
dim 1 : 5 cells
dim 2 : 1 cells
10 total
Let’s now compute homology.
using F2 = ModP<int, 2>;
auto R = bats::Reduce(X, F2());
R.print_summary();
The output of bats::Reduce
will be a ReducedChainComplex with F2 coefficients,
which holds information used to compute homology.
The output of R.print_summary()
will be
ReducedChainComplex, maxdim = 2
dim 0: 4, betti_0: 1
dim 1: 5, betti_1: 1
dim 2: 1, betti_2: 0
Persistent Homology¶
A filtration in BATS is a class which is templated over the type of the filtration values as well as the type of the underlying complex.
bats::Filtration<double, bats::SimplicialComplex> F;
std::vector<size_t> spx;
spx = {0,1,2}; F.add_recursive(0.0, spx);
spx = {2,3}; F.add_recursive(1.0, spx);
spx = {1,3}; F.add(2.0, spx);
F.complex().print_summary();
The underlying SimplicialComplex is the same as in the previous example:
SimplicialComplex, maxdim = 2
dim 0 : 4 cells
dim 1 : 5 cells
dim 2 : 1 cells
10 total
Again, we can use the Reduce
function to compute homology. Because we
are using a filtration as input, persistent homology will be computed, returning
a ReducedFilteredChainComplex.
using F2 = ModP<int, 2>;
auto R = bats::Reduce(F, F2());
for (size_t k = 0; k < R.maxdim(); ++k) {
std::cout << "\n" << k << "-dimensional barcode:\n";
for ( auto p : R.persistence_pairs(k)) {
std::cout << p.str() << std::endl;
}
}
The output will show one persistent 0-dimensional homology class as well as one persistent 1-dimensional homology class
0-dimensional barcode:
0 : (0,inf) <0,-1>
0 : (0,0) <1,0>
0 : (0,0) <2,1>
0 : (1,1) <3,3>
1-dimensional barcode:
1 : (0,0) <2,0>
1 : (2,inf) <4,-1>
The output of R.persistence_pairs(k)
is a vector of PersistencePairs
for k-dimensional persistent homology.
A PersistencePair includes 5 pieces of information: * The dimension of the homology class. * The birth and death parameters of the homology class. * The simplex indices responsible for birth and death.
Maps¶
BATS makes dealing with maps between topological spaces and associated chain maps and induced maps on homology easy. The relevant class is a CellularMap which keeps track of what cells in one complex map to what cells in another.
We’ll just look at a wrapper for CellularMap, called SimplcialMap which can be used to extend a map on the vertex set of a SimplicialComplex to a map of simplices.
First, we’ll build identical simplicial complexes X and Y which are both cycle graphs on four vertices.
bats::SimplicialComplex X;
X.add_recursive({0,1});
X.add_recursive({1,2});
X.add_recursive({2,3});
X.add_recursive({0,3});
bats::SimplicialComplex Y = X; // copy
We then build a simplicial map from X to Y which is extended from a reflection of the vertices.
std::vector<size_t> f0{2,1,0,3}; // reflection map
auto F = bats::SimplicialMap(X, Y, f0);
The map is extended by sending vertex i
in X to vertex
f0[i]
in Y. Next, we can apply the chain functor. We’ll use
F3 coefficients.
// apply the chain functor
using F3 = ModP<int, 3>;
auto CX = bats::Chain(X, F3());
auto CY = bats::Chain(Y, F3());
auto CF = bats::Chain(F, F3());
Finally, we can compute homology of the chain complexes and the induced maps.
auto RX = bats::ReducedChainComplex(CX);
auto RY = bats::ReducedChainComplex(CY);
RX.print_summary();
RY.print_summary();
for (size_t k = 0; k < 2; k++) {
std::cout << "\nInduced map in dimension " << k << std::endl;
auto HF = bats::induced_map(CF, RX, RY, k);
HF.print();
}
The following output will be produced:
ReducedChainComplex, maxdim = 1
dim 0: 4, betti_0: 1
dim 1: 4, betti_1: 1
ReducedChainComplex, maxdim = 1
dim 0: 4, betti_0: 1
dim 1: 4, betti_1: 1
Induced map in dimension 0
[0x7fff6f336460] : 1 x 1 ColumnMatrix
1
Induced map in dimension 1
[0x7fff6f336460] : 1 x 1 ColumnMatrix
2
As expected, we see that X and Y both have 1-dimensional homology in dimensions 0 and 1. The induced map in dimension 0 is the identity, and the induced map in dimension 1 is multiplication by -1 (in mod-3 coefficients).
Zigzag Homology¶
We’ll now compute a simple zigzag barcode, using the above example. We’ll consider a diagram with two (identical) spaces, connected by a single edge which applies the reflection map in the above example.
bats::Diagram<bats::SimplicialComplex, bats::CellularMap> D(2,1);
bats::SimplicialComplex X;
X.add_recursive({0,1});
X.add_recursive({1,2});
X.add_recursive({2,3});
X.add_recursive({0,3});
std::vector<size_t> f0{2,1,0,3}; // reflection map
auto F = bats::SimplicialMap(X, X, f0);
D.set_node(0, X);
D.set_node(1, X);
D.set_edge(0, 0, 1, F); // edge 0: (0,1)
We can then apply the Chain and Hom functors, to obtain a diagram of homology spaces and maps between them
using F3 = ModP<int, 3>;
auto CD = bats::Chain(D, F3());
auto HD = bats::Hom(CD, (size_t) 1); // homology in dimension 1
Finally, we extract the barcode from the homology diagram
auto ps = barcode(HD, 1);
for (auto p : ps) {
std::cout << p.str() << std::endl;
}
The output should look like: 1 : (0,1) <0,0>. This indicates there is a 1-dimensional homology bar, which is born in the space with index 0 and survives until the space with index 1. The <0,0> indicates which generators are associated with the homology class in the diagram.
Source Code¶
1#include <vector>
2#include <iostream>
3#include <bats.hpp>
4
5int main() {
6
7 // Simplicial complexes and Homology
8 {
9 bats::SimplicialComplex X;
10 X.add_recursive({0,1,2});
11 X.add_recursive({2,3});
12 X.add({1,3});
13
14 X.print_summary();
15
16 using F2 = ModP<int, 2>;
17 auto R = bats::Reduce(X, F2());
18
19 R.print_summary();
20 }
21
22 // Persistent homology
23 {
24 bats::Filtration<double, bats::SimplicialComplex> F;
25 std::vector<size_t> spx;
26 spx = {0,1,2}; F.add_recursive(0.0, spx);
27 spx = {2,3}; F.add_recursive(1.0, spx);
28 spx = {1,3}; F.add(2.0, spx);
29
30 F.complex().print_summary();
31
32 using F2 = ModP<int, 2>;
33 auto R = bats::Reduce(F, F2());
34
35 for (size_t k = 0; k < R.maxdim(); ++k) {
36 std::cout << "\n" << k << "-dimensional barcode:\n";
37 for ( auto p : R.persistence_pairs(k)) {
38 std::cout << p.str() << std::endl;
39 }
40 }
41 }
42
43 // Maps
44 {
45 bats::SimplicialComplex X;
46 X.add_recursive({0,1});
47 X.add_recursive({1,2});
48 X.add_recursive({2,3});
49 X.add_recursive({0,3});
50 bats::SimplicialComplex Y = X; // copy
51
52 X.print_summary();
53
54 std::vector<size_t> f0{2,1,0,3}; // reflection map
55 auto F = bats::SimplicialMap(X, Y, f0);
56
57 // apply the chain functor
58 using F3 = ModP<int, 3>;
59 auto CX = bats::Chain(X, F3());
60 auto CY = bats::Chain(Y, F3());
61 auto CF = bats::Chain(F, F3());
62
63 auto RX = bats::ReducedChainComplex(CX);
64 auto RY = bats::ReducedChainComplex(CY);
65 RX.print_summary();
66 RY.print_summary();
67
68 for (size_t k = 0; k < 2; k++) {
69 std::cout << "\nInduced map in dimension " << k << std::endl;
70 auto HF = bats::induced_map(CF, RX, RY, k);
71 HF.print();
72 }
73 }
74
75 // Zigzag homology
76 std::cout << "\nZigzag Example\n";
77 {
78 bats::Diagram<bats::SimplicialComplex, bats::CellularMap> D(2,1);
79
80 bats::SimplicialComplex X;
81 X.add_recursive({0,1});
82 X.add_recursive({1,2});
83 X.add_recursive({2,3});
84 X.add_recursive({0,3});
85
86 std::vector<size_t> f0{2,1,0,3}; // reflection map
87 auto F = bats::SimplicialMap(X, X, f0);
88
89 D.set_node(0, X);
90 D.set_node(1, X);
91 D.set_edge(0, 0, 1, F); // edge 0: (0,1)
92
93 using F3 = ModP<int, 3>;
94 auto CD = bats::Chain(D, F3());
95
96 auto HD = bats::Hom(CD, (size_t) 1); // homology in dimension 1
97
98 auto ps = bats::barcode(HD, 1);
99 for (auto p : ps) {
100 std::cout << p.str() << std::endl;
101 }
102
103
104 }
105
106
107 return EXIT_SUCCESS;
108}
Tutorials¶
Complexes¶
This tutorial will cover building and using complexes which represent topological spaces.
Interfaces¶
Chain Functor¶
There are several functions a complex should implement in order to be compatible with the chain functor.
Filtrations¶
Filtrations can be created from a complex as well as a list of filtration values. However, in order to construct filtrations incrementally the following methods should be implemented.
Examples¶
Zigzag Filtrations¶
A zigzag filtration allows cells to enter and exit a complex at specified
parameters. Construction is similar to a filtration, but you need to specify
entry as well as exit time. Zigzag filtration functionality is
under the bats::zigzag
namespace.
bats::zigzag::ZigzagFiltration<bats::SimplicialComplex> F;
std::vector<size_t> spx;
// create a cycle that persists for a while
spx = {0,1}; F.add_recursive(0.0, 10.0, spx);
spx = {0,2}; F.add_recursive(0.0, 10.0, spx);
spx = {1,2}; F.add_recursive(0.0, 10.0, spx);
// now block cycle for some period of time
spx = {0,1,2}; F.add(2.0, 4.0, spx);
You can compute a barcode using bats::barcode
using F2 = ModP<int, 2>;
auto ps = bats::zigzag::barcode(F, 1, F2(),
bats::no_optimization_flag(),
bats::standard_reduction_flag()
);
for (auto& pk : ps) {
for (auto p : pk) {
if (p.length() > 0)
std::cout << p << std::endl;
}
}
You should see the following output
0 : (0,10) <0(1),0(0)>
1 : (0,2) <2(1),0(1)>
1 : (4,10) <0(0),2(0)>
This indicates that there is a single connected component in the zigzag filtration. The two H1 classes correspond to the cycle, which isn’t present when we put in the triangle between parameters 2 and 4.
Library API¶
Class Hierarchy¶
-
- Namespace bats
- Namespace bats::flags
- Struct divide_conquer
- Struct leftward
- Struct rightward
- Namespace bats::future
- Struct ColumnMajor
- Struct ElementaryPermutation
- Template Struct LUFact
- Struct RowMajor
- Template Struct SimilarityTransform
- Class CompositePermutation
- Template Class const_strided_iterator
- Template Class Matrix
- Template Class MatrixView
- Class Permutation
- Template Class range
- Class range::const_iterator
- Template Class Span
- Template Class strided_iterator
- Template Class VectorView
- Namespace bats::util
- Struct SimplexHasher
- Class SimplexContainer
- Namespace bats::zigzag
- Template Struct rfilt_val
- Template Struct ZigzagChainComplex
- Template Struct ZigzagPair
- Template Class ZigzagFiltration
- Template Struct AbstractMetric
- Struct AngleDist
- Struct apparent_pairs_flag
- Struct bar
- Template Struct ChainComplex
- Template Struct ChainMap
- Struct clearing_flag
- Template Struct CochainComplex
- Struct compression_flag
- Struct compute_basis_flag
- Struct CosineDist
- Template Struct DataSet
- Template Struct DGLinearMap
- Template Struct DGVectorSpace
- Struct divide_conquer_flag
- Struct Euclidean
- Struct extra_reduction_flag
- Template Struct filtered_edge
- Template Struct FilteredChainComplex
- Template Struct FilteredCochainComplex
- Struct L1Dist
- Struct LInfDist
- Struct no_apparent_pairs_flag
- Struct no_optimization_flag
- Template Struct PersistencePair
- Template Struct ReducedDGVectorSpace
- Template Struct ReducedFilteredChainComplex
- Struct RPAngleDist
- Struct RPCosineDist
- Struct sparse_reduction_flag
- Struct standard_reduction_flag
- Template Struct tedge
- Struct triangle
- Template Struct Update_info
- Template Class BarcodePair
- Class CellComplex
- Class CellularMap
- Class CubicalComplex
- Template Class Diagram
- Struct Diagram::Edge
- Template Class Filtration
- Template Class LightSimplicialComplex
- Template Class ReducedChainComplex
- Template Class ReducedCochainComplex
- Class SimplicialComplex
- Template Class SparseTrie
- Namespace bats::flags
- Template Struct A
- Struct cell_ind
- Template Struct D
- Template Struct E
- Template Struct EL
- Template Struct ELH
- Template Struct EU
- Template Struct EUH
- Template Struct is_UnivariatePolynomial
- Template Struct is_UnivariatePolynomial< UnivariatePolynomial< T > >
- Template Struct L
- Struct MAT
- Template Struct nzpair
- Template Struct P
- Struct SI
- Template Struct SmithFact
- Template Struct SparseFact
- Template Struct T
- Template Struct U
- Template Class AbstractField
- Class AbstractMatrix
- Template Class ColumnMatrix
- Template Class CSCMatrix
- Template Class ModP
- Template Class ModP< IntT, 2 >
- Template Class MorsePairing
- Template Class MultiGraph
- Struct MultiGraph::Edge
- Struct MultiGraph::Node
- Template Class Rational
- Template Class SetVector
- Template Class SparseVector
- Template Class UnivariatePolynomial
- Namespace bats
File Hierarchy¶
-
- Directory include
- Directory chain
- Directory complex
- File abstract_complex.hpp
- File cell_complex.hpp
- File cell_map.hpp
- File cubical_complex.hpp
- File cubical_map.hpp
- File light_simplicial_complex.hpp
- File simplicial_complex.hpp
- File simplicial_map.hpp
- Directory dgvs
- Directory filtration
- File extension.hpp
- File filtration.hpp
- File flag.hpp
- File rips.hpp
- File star.hpp
- File update_information.hpp
- Directory future
- File dense.hpp
- File lu.hpp
- File permutation.hpp
- File similarity.hpp
- File span.hpp
- File util.hpp
- Directory homology
- File basis.hpp
- File cohom_basis.hpp
- File dgbasis.hpp
- File induced_map.hpp
- File parallel.hpp
- File reduction.hpp
- Directory linalg
- File abstract_matrix.hpp
- File abstract_vector.hpp
- File col_matrix.hpp
- File csc_matrix.hpp
- File field.hpp
- File matrix_interface.hpp
- File naive_dense.hpp
- File pid.hpp
- File polynomial.hpp
- File rcf.hpp
- File schur.hpp
- File set_vector.hpp
- File sparse_fact.hpp
- File sparse_vector.hpp
- File symbolic_implementation.hpp
- Directory morse
- File pairing.hpp
- Directory multigraph
- File diagram.hpp
- File functors.hpp
- File multigraph.hpp
- Directory persistence
- File barcode.hpp
- File extract.hpp
- File filtered_basis.hpp
- File filtered_dual.hpp
- File filtration.hpp
- Directory quiver
- File sparse.hpp
- Directory topology
- File cover.hpp
- File data.hpp
- File data_gen.hpp
- File density.hpp
- File dowker.hpp
- File dowker_cover.hpp
- File eilenberg_zilber.hpp
- File extras.hpp
- File flag.hpp
- File grid.hpp
- File inclusion.hpp
- File landmark.hpp
- File levelset.hpp
- File mayer_vietoris.hpp
- File metric.hpp
- File neighborhood.hpp
- File nerve.hpp
- File rips.hpp
- File rips_cover.hpp
- File spherical.hpp
- File zigzag_zoo.hpp
- Directory util
- File barcode.hpp
- File common.hpp
- File io.hpp
- File permutation.hpp
- File print.hpp
- File set.hpp
- File simplex.hpp
- File sorted.hpp
- File trie.hpp
- Directory zigzag
- File extension.hpp
- File reduction.hpp
- File zigzag_filtration.hpp
- File bats.hpp
- File chain.hpp
- File complex.hpp
- File dgvs.hpp
- File filtration.hpp
- File future.hpp
- File homology.hpp
- File linalg.hpp
- File multigraph.hpp
- File persistence.hpp
- File quiver.hpp
- File topology.hpp
- File zigzag.hpp
- Directory include
Full API¶
Namespaces¶
Namespace bats¶
We need to specify what is the conventional usage of permutation in bats!! [2, 0, 1] apply to [2.0 , 1.0 ,5.0] a) is [5.0, 2.0, 1.0] in matrix permutation notation b) is [1.0, 5.0 ,2.0] in traditioanl notation(in book From Mathematics to Generic Programming) We take the frist notation here, but notice that BATs, sometimes, will mix the two notations!!! Check before use!!! Since the above two notations are inverse to each other, inverse them if needed! Constructions on a grid Freudenthal triangulation
Template Function bats::__ChainComplex(const CpxT&, const CpxT&, T)
Template Function bats::add_dimension_recursive_flag_extension
Template Function bats::add_normal_noise(Matrix<T>&, const T, const T)
Template Function bats::add_normal_noise(DataSet<T>&, unsigned, const T, const T)
Template Function bats::add_normal_noise(DataSet<T>&, const T, const T)
Template Function bats::add_normal_noise(Matrix<T>&, unsigned, const T, const T)
Template Function bats::add_uniform_noise(Matrix<T>&, unsigned, const T, const T)
Template Function bats::add_uniform_noise(Matrix<T>&, const T, const T)
Template Function bats::add_uniform_noise(DataSet<T>&, const T, const T)
Template Function bats::barcode(const Diagram<NT, TM>&, size_t, flags::rightward)
Template Function bats::barcode(const Diagram<NT, TM>&, size_t, flags::leftward)
Template Function bats::barcode(const Diagram<NT, TM>&, size_t, flags::divide_conquer)
Template Function bats::barcode(const Diagram<NT, std::vector<TM>>&, Args …)
Template Function bats::barcode(const Diagram<NT, TM>&, size_t)
Template Function bats::Chain(const Filtration<FT, CpxT>&, T)
Template Function bats::Chain(const Diagram<CpxT, CellularMap>&, T)
Function bats::Cube(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t)
Template Function bats::dowker_edge_param(const Matrix<T>&, const size_t, const size_t)
Template Function bats::DowkerFiltration(const DataSet<T>&, const DataSet<T>&, const M&, T, size_t)
Template Function bats::DowkerFiltration(const Matrix<T>&, T, size_t)
Template Function bats::DowkerFiltration(const Matrix<T>&, const bats::Cover&, T, size_t)
Template Function bats::EilenbergZilber(const CpxT&, const CpxT&, const size_t, T)
Template Function bats::extract_basis_indices(const MT&, const std::vector<size_t>&)
Template Function bats::filtration_sortperm(const std::vector<std::vector<T>>&)
Template Function bats::filtration_sortperm(const std::vector<T>&)
Template Function bats::Freudenthal(const CubicalComplex&, size_t, size_t, size_t)
Template Function bats::greedy_landmarks_hausdorff(const Matrix<T>&, const size_t)
Template Function bats::greedy_landmarks_hausdorff(const DataSet<T>&, const M&, const size_t)
Template Function bats::Hom(const Diagram<ChainComplex<TM>, ChainMap<TM>>&, bool)
Template Function bats::Hom(const Diagram<DGVectorSpace<TM>, DGLinearMap<TM>>&, size_t)
Template Function bats::Hom(const Diagram<ChainComplex<TM>, ChainMap<TM>>&, size_t)
Template Function bats::neighborhood(const VectorView<T>&, const DataSet<T>&, const M&, const T)
Template Function bats::neighborhoods(const DataSet<T>&, const DataSet<T>&, const M&, const T)
Template Function bats::neighborhoods(const Matrix<T>&, const T)
Template Function bats::neighborhoods(const DataSet<T>&, const DataSet<T>&, const M&, const size_t)
Function bats::Nerve(const Diagram<bats::Cover, std::vector<size_t>>&, const size_t)
Template Function bats::partial_reduce_parallel(ColumnMatrix<TVec>&, const size_t)
Function bats::perm_to_the_end(const size_t&, const size_t&)
Function bats::perm_to_the_end(const std::vector<size_t>&, const size_t&)
Template Function bats::Reduce(const ChainComplex<MT>&, Args …)
Template Function bats::Reduce(const FilteredChainComplex<T, MT>&, Args …)
Template Function bats::Reduce(const Filtration<FT, CpxT>&, T, Args …)
Template Function bats::reduce_block_sequential(ColumnMatrix<TVec>&, const size_t, const size_t)
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, bats::extra_reduction_flag)
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, divide_conquer_flag)
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, bats::standard_reduction_flag)
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, divide_conquer_flag)
Template Function bats::reduce_matrix_extra(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)
Template Function bats::reduce_matrix_extra(ColumnMatrix<TVec>&)
Template Function bats::reduce_matrix_standard(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)
Template Function bats::reduce_matrix_standard(ColumnMatrix<TVec>&)
Template Function bats::rips_edges(const Matrix<T>&, const T)
Template Function bats::rips_edges(const DataSet<T>&, const M&, const T)
Template Function bats::rips_edges(std::vector<T>&, std::vector<size_t>&, std::vector<T>&)
Template Function bats::rips_filtration_edges(const Matrix<T>&, const T)
Template Function bats::rips_filtration_edges(const DataSet<T>&, const M&, const T)
Template Function bats::RipsComplex(const Matrix<T>&, T, size_t)
Template Function bats::RipsComplex(const DataSet<T>&, const M&, T, size_t)
Template Function bats::RipsFiltration(const Matrix<T>&, T, size_t)
Template Function bats::RipsFiltration(const DataSet<T>&, const M&, T, size_t)
Template Function bats::RipsFiltration(const DataSet<T>&, const bats::Cover&, const M&, T, size_t)
Template Function bats::RipsFiltration_extension(const Matrix<T>&, T, size_t)
Template Function bats::RipsFiltration_extension(const DataSet<T>&, const M&, T, size_t)
Template Function bats::sample_cube(const size_t, const size_t, unsigned)
Template Function bats::sample_cube(const size_t, const size_t)
Template Function bats::SimplicialMap(const CpxT&, const CpxT&, const std::vector<size_t>&)
Template Function bats::SimplicialMap(const CpxT&, const CpxT&)
Template Function bats::sparsify_basis(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)
Template Function bats::TriangulatedProduct(const CpxT&, const CpxT&)
Template Function bats::TriangulatedProduct(const CpxT&, const CpxT&, const size_t)
Template Function bats::TriangulatedProduct(const CpxT&, const CpxT&, const size_t, const size_t)
Template Function bats::witness_edges(const DataSet<T>&, const DataSet<T>&, const M&, const T)
Template Function bats::witness_edges(const DataSet<T>&, const DataSet<T>&, const M&)
Template Function bats::WitnessComplex(const DataSet<T>&, const DataSet<T>&, const M&, const size_t)
Namespace bats::flags¶
Contents
Namespace bats::future¶
Template Function bats::future::find_pivot_high(const RandomAccessIterator&, ssize_t)
Template Function bats::future::find_pivot_high(const RandomAccessIterator&, ssize_t, ssize_t)
Template Function bats::future::gemv(const MT&, const VT1&, VT2&&)
Template Function bats::future::l_residual(const MT&&, I1&&)
Template Function bats::future::l_solve(const MT&, I1&, I2&)
Template Function bats::future::l_solve(const MT1&, const MT2&, I1&, I2&)
Function bats::future::operator<<(std::ostream&, const CompositePermutation&)
Function bats::future::operator<<(std::ostream&, const ElementaryPermutation&)
Namespace bats::rowmajor¶
Contents
Namespace bats::util¶
Contents
Template Function bats::util::apply_perm(T, std::vector<T2>&, const std::vector<size_t>&)
Template Function bats::util::apply_perm(T *, const std::vector<size_t>&)
Template Function bats::util::apply_perm(std::vector<T>&, const std::vector<size_t>&)
Template Function bats::util::fill_sortperm(const T&, const T&, std::vector<size_t>&)
Template Function bats::util::fill_sortperm(const std::vector<T>&, std::vector<size_t>&)
Template Function bats::util::intersect_sorted(const C1&, const C2&, std::vector<T>&)
Template Function bats::util::intersect_sorted(const C1&, const C2&, std::set<T>&)
Template Function bats::util::sortperm(const std::vector<T>&)
Template Function bats::util::sortperm(const size_t, const size_t, Compare)
Template Function bats::util::sortperm(const TI&, const TI&)
Template Function bats::util::write_simplex(IO&, TI&&, TI&&)
Template Function bats::util::write_simplex(IO&, std::vector<T>&)
Namespace bats::zigzag¶
Contents
Namespace bats::zigzag::detail¶
Contents
Classes and Structs¶
Template Struct A¶
Defined in File matrix_interface.hpp
public MAT
(Struct MAT)
public E< Impl >
(Template Struct E)public T< Impl >
(Template Struct T)
Struct AngleDist¶
Defined in File metric.hpp
public bats::AbstractMetric< AngleDist >
(Template Struct AbstractMetric)
Struct apparent_pairs_flag¶
Defined in File reduction.hpp
Template Struct ChainComplex¶
Defined in File chain_complex.hpp
-
template<typename MT>
struct bats::ChainComplex¶ Public Functions
-
inline ChainComplex()¶
-
inline ChainComplex(size_t maxd)¶
-
inline size_t maxdim() const¶
-
inline size_t dim(size_t k) const¶
-
inline size_t dim() const¶
-
inline bool is_valid_complex() const¶
-
inline ChainComplex subcomplex(std::vector<std::vector<size_t>> &inds) const¶
-
inline ChainComplex relative_complex(std::vector<std::vector<size_t>> &inds) const¶
-
inline void permute_basis(size_t k, const std::vector<size_t> &perm)¶
-
inline void permute_basis(const std::vector<std::vector<size_t>> &perm)¶
-
inline void ipermute_basis(size_t k, const std::vector<size_t> &perm)¶
-
inline void ipermute_basis(const std::vector<std::vector<size_t>> &perm)¶
-
template<typename Information_type>
inline void update_basis_general(size_t k, const Information_type &UI)¶
-
template<typename Information_type>
inline void update_basis_general(const Information_type &UI_fast)¶
Friends
- inline friend friend ChainComplex tensor_product (const ChainComplex &A, const ChainComplex &B, size_t dmax)
- inline friend friend ChainComplex tensor_product (const ChainComplex &A, const ChainComplex &B)
-
inline ChainComplex()¶
Template Struct ChainMap¶
Defined in File chain_map.hpp
-
template<typename TM>
struct bats::ChainMap¶ Public Functions
-
inline ChainMap()¶
-
inline ChainMap(size_t d)¶
-
inline ChainMap(const CellularMap &f)¶
-
template<typename CpxT>
inline ChainMap(const CellularMap &f, const CpxT &X, const CpxT &A, const CpxT &Y, const CpxT &B)¶
-
inline ChainMap relative_map(std::vector<std::vector<size_t>> &inds1, std::vector<std::vector<size_t>> &inds2) const¶
-
inline size_t maxdim() const¶
-
inline void permute_row_basis(size_t k, const std::vector<size_t> &p)¶
-
inline void permute_column_basis(size_t k, const std::vector<size_t> &p)¶
-
inline ChainMap()¶
Template Struct CochainComplex¶
Defined in File cochain_complex.hpp
-
template<typename MT>
struct bats::CochainComplex¶
Struct compression_flag¶
Defined in File reduction.hpp
Struct compute_basis_flag¶
Defined in File basis.hpp
Struct CosineDist¶
Defined in File metric.hpp
public bats::AbstractMetric< CosineDist >
(Template Struct AbstractMetric)
-
struct bats::CosineDist : public bats::AbstractMetric<CosineDist>¶
Template Struct DGLinearMap¶
Defined in File dgmap.hpp
-
template<typename TM>
struct bats::DGLinearMap¶ A class for a map between two DGVectorSpaces
The map should be between DGVectorspaces of the same degree and the map should commute with the differential.
If the DGVectorspaces are augmented, the map should be augmentation preserving.
Public Functions
-
inline DGLinearMap()¶
-
inline DGLinearMap(size_t d)¶
-
inline DGLinearMap(const CellularMap &f, int deg = -1)¶
-
inline ssize_t maxdim() const¶
-
inline void permute_row_basis(ssize_t k, const std::vector<size_t> &p)¶
-
inline void permute_column_basis(ssize_t k, const std::vector<size_t> &p)¶
-
inline DGLinearMap()¶
Template Struct DGVectorSpace¶
Defined in File dgvs.hpp
-
template<typename MT>
struct bats::DGVectorSpace¶ a class for a differential graded vector space.
This encapsulates both chain and cochain complex constructions
degree is the degree of the differential: -1 for chain complexes (default) +1 for cochain complexes
differential holds the differential maps
We store maps starting on the edge (-1,0) (-1) (0) (1) (2) … This map is 0 in the case of standard chain/cochain complexes but can be non-zero for augmented chain/cochain complexes
TODO: need to handle +1 boundary in maxdim
Public Functions
-
inline MT &operator[](ssize_t k)¶
Access maps in various dimensions
if degree is +1 (cohomolgical type), then lowest map index is -1 -[-1]-> * -[0]-> * -[1]-> …
if degree is -1 (homological type) then lowest map index is 0 <-[0]- * <-[1]- * <-[2]- …
-
inline DGVectorSpace()¶
-
inline DGVectorSpace(size_t maxd, int deg = -1)¶
Construct a DGVector space with maxd dimensions
-
inline DGVectorSpace(const std::vector<MT> &diff, int deg = -1)¶
Construct a DGVector space explicitly from differentials
-
template<typename CpxT>
inline DGVectorSpace(const CpxT &X, const int deg = -1, const bool augmented = false)¶
-
inline ssize_t maxdim() const¶
-
inline size_t dim(ssize_t k) const¶
-
inline MT &operator[](ssize_t k)¶
Struct divide_conquer_flag¶
Defined in File parallel.hpp
Struct Euclidean¶
Defined in File metric.hpp
public bats::AbstractMetric< Euclidean >
(Template Struct AbstractMetric)
Struct extra_reduction_flag¶
Defined in File reduction.hpp
Template Struct filtered_edge¶
Defined in File flag.hpp
Template Struct FilteredChainComplex¶
Defined in File filtered_chain_complex.hpp
-
template<typename FT, typename MT>
struct bats::FilteredChainComplex¶ Public Functions
-
inline FilteredChainComplex()¶
-
template<typename CpxT>
inline FilteredChainComplex(const Filtration<FT, CpxT> &F)¶
-
inline size_t dim(const size_t k)¶
-
inline const ChainComplex<MT> &complex() const¶
-
inline FilteredChainComplex()¶
Template Struct FilteredCochainComplex¶
Defined in File filtered_cochain_complex.hpp
-
template<typename FT, typename MT>
struct bats::FilteredCochainComplex¶ Public Functions
-
inline FilteredCochainComplex()¶
-
template<typename CpxT>
inline FilteredCochainComplex(const Filtration<FT, CpxT> &F)¶
-
inline size_t dim(const size_t k)¶
-
inline const CochainComplex<MT> &complex() const¶
-
inline FilteredCochainComplex()¶
Struct divide_conquer¶
Defined in File sparse.hpp
Struct leftward¶
Defined in File sparse.hpp
Struct rightward¶
Defined in File sparse.hpp
Struct ElementaryPermutation¶
Defined in File permutation.hpp
-
struct bats::future::ElementaryPermutation¶
Public Functions
-
inline ElementaryPermutation()¶
-
inline ElementaryPermutation(size_t i, size_t j)¶
-
inline CompositePermutation &operator()(CompositePermutation &a) const¶
Friends
- friend friend std::ostream & operator<< (std::ostream &os, const ElementaryPermutation &p)
-
inline ElementaryPermutation()¶
Template Struct SimilarityTransform¶
Defined in File similarity.hpp
Struct L1Dist¶
Defined in File metric.hpp
public bats::AbstractMetric< L1Dist >
(Template Struct AbstractMetric)
Struct LightSimplicialComplex::simplex_boundary_iterator¶
Defined in File light_simplicial_complex.hpp
This struct is a nested type of Template Class LightSimplicialComplex.
-
struct bats::LightSimplicialComplex::simplex_boundary_iterator¶
Public Functions
-
inline simplex_boundary_iterator(index_type s, size_t dim, const LightSimplicialComplex *p)¶
-
inline simplex_boundary_iterator(index_type s, size_t dim, const LightSimplicialComplex *p, int i)¶
-
inline simplex_boundary_iterator(int i)¶
-
inline std::tuple<index_type, int> next()¶
-
inline index_type operator*() const¶
-
inline simplex_boundary_iterator &operator++()¶
-
inline simplex_boundary_iterator &operator--()¶
-
inline bool operator!=(const simplex_boundary_iterator &other)¶
-
inline bool operator==(const simplex_boundary_iterator &other)¶
-
inline operator bool() const¶
-
inline simplex_boundary_iterator(index_type s, size_t dim, const LightSimplicialComplex *p)¶
Struct LInfDist¶
Defined in File metric.hpp
public bats::AbstractMetric< LInfDist >
(Template Struct AbstractMetric)
Struct no_apparent_pairs_flag¶
Defined in File reduction.hpp
Struct no_optimization_flag¶
Defined in File reduction.hpp
Template Struct PersistencePair¶
Defined in File barcode.hpp
-
template<typename T>
struct bats::PersistencePair¶ Public Functions
-
inline PersistencePair()¶
-
inline PersistencePair(const size_t dim, const size_t birth_ind, const size_t death_ind, const T birth, const T death)¶
-
inline bool operator==(const PersistencePair &other) const¶
-
inline bool operator!=(const PersistencePair &other) const¶
-
inline size_t get_dim() const¶
-
inline size_t get_birth_ind() const¶
-
inline size_t get_death_ind() const¶
-
inline std::string str()¶
-
inline PersistencePair()¶
Template Struct ReducedDGVectorSpace¶
Defined in File dgbasis.hpp
-
template<typename MT>
struct bats::ReducedDGVectorSpace¶ -
Public Functions
-
inline size_t hdim(size_t k) const¶
-
inline size_t betti(size_t k) const¶
-
inline size_t maxdim() const¶
-
inline size_t dim(size_t k) const¶
-
inline void initialize(const DGVectorSpace<MT> &C)¶
initialize with chain complex C, but do not do reduction
-
inline void set_indices()¶
-
inline ReducedDGVectorSpace()¶
-
inline ReducedDGVectorSpace(const DGVectorSpace<MT> &C)¶
-
template<typename TV>
inline TV to_hom_basis(const TV &v, size_t k) const¶ put vector/matrix in homology-revealing basis in dimension k
-
template<typename TV>
inline TV from_hom_basis(const TV &v, size_t k) const¶ put vector/matrix back in original basis in dimension k
-
inline void print_summary(bool print_nnz = false) const¶
-
inline size_t hdim(size_t k) const¶
Template Struct ReducedFilteredChainComplex¶
Defined in File filtered_basis.hpp
-
template<typename T, typename MT>
struct bats::ReducedFilteredChainComplex¶ Public Functions
-
inline ReducedFilteredChainComplex()¶
-
template<typename ...Args>
inline ReducedFilteredChainComplex(const FilteredChainComplex<T, MT> &C, Args... args)¶
-
inline size_t maxdim() const¶
-
inline size_t dim(const size_t k) const¶
-
inline size_t hdim(const size_t k) const¶
-
inline std::vector<PersistencePair<T>> persistence_pairs(const size_t k, const bool permuted = false) const¶
persistence pairs in dimension k
- Parameters
k – homology dimension
permuted – set to true to return critical indices permuted by filtration parameter set to false to return with indices in original order. Default: false
-
inline auto representative(const PersistencePair<T> &p, const bool permuted = false) const¶
returns representative for homology class corresponding to persistence pair
if permuted is false, it is assumed the birth index is also not in permutation order.
- Parameters
p – persistence pair obtained from persistence_pairs
permuted – set to true to return indices permuted by filtration parameter set to false to return with indices in original order. Default: false
-
std::vector<size_t> critical_cells(const size_t k)¶
-
template<typename Information_type, typename ...Args>
inline void update_filtration_general(const Information_type &updating_information, Args... args)¶
-
inline std::vector<size_t> get_nnz_U()¶
-
inline std::vector<size_t> get_nnz_R()¶
-
inline void sparsify_basis()¶
greedily introduce sparsity into basis
-
ReducedFilteredChainComplex get_subcomplex() const¶
-
inline void print_summary(bool print_nnz = false) const¶
-
inline ReducedFilteredChainComplex()¶
Struct RPAngleDist¶
Defined in File metric.hpp
public bats::AbstractMetric< RPAngleDist >
(Template Struct AbstractMetric)
-
struct bats::RPAngleDist : public bats::AbstractMetric<RPAngleDist>¶
Struct RPCosineDist¶
Defined in File metric.hpp
public bats::AbstractMetric< CosineDist >
(Template Struct AbstractMetric)
-
struct bats::RPCosineDist : public bats::AbstractMetric<CosineDist>¶
Struct sparse_reduction_flag¶
Defined in File reduction.hpp
Struct standard_reduction_flag¶
Defined in File reduction.hpp
Template Struct Update_info¶
Defined in File update_information.hpp
-
template<class FiltrationType>
struct bats::Update_info¶ Public Functions
-
inline Update_info(const FiltrationType &F_X, const FiltrationType &F_Y)¶
-
inline void filtered_info(const std::vector<std::vector<size_t>> &perms_X)¶
-
inline std::vector<size_t> permutation_deletion_end(size_t i)¶
-
inline void print_summary()¶
-
inline void print_detail()¶
Public Members
-
std::vector<std::vector<size_t>> addition_indices¶
-
std::vector<std::vector<std::vector<size_t>>> boundary_indices¶
-
std::vector<std::vector<size_t>> deletion_indices¶
-
std::vector<std::vector<size_t>> permutations¶
-
std::vector<std::vector<size_t>> intersection_indices_Y¶
-
std::vector<std::vector<size_t>> intersection_indices_X¶
-
size_t max_dim¶
-
std::vector<std::vector<double>> F_X_vals¶
-
std::vector<std::vector<size_t>> F_X_perms¶
-
std::vector<std::vector<size_t>> perms_X_inv¶
-
std::vector<std::vector<double>> F_Y_vals¶
-
std::vector<std::vector<size_t>> F_Y_perms¶
-
std::vector<std::vector<size_t>> perms_Y_inv¶
-
FiltrationType F_old¶
-
FiltrationType F_new¶
-
bool filtered_boolean = false¶
-
inline Update_info(const FiltrationType &F_X, const FiltrationType &F_Y)¶
Struct SimplexHasher¶
Defined in File simplex.hpp
Template Struct rfilt_val¶
Defined in File reduction.hpp
Template Struct ZigzagChainComplex¶
Defined in File zigzag_filtration.hpp
-
template<typename MT, typename T = double>
struct bats::zigzag::ZigzagChainComplex¶ A class that wraps a chain complex with a zigzag filtration.
A class that wraps a chain complex with a zigzag filtration. Unlike a Zigzag filtraion, every chain has a unique entry and removal time.
Public Functions
-
inline void _correct_indices(size_t k, size_t j, const std::vector<std::vector<size_t>> extra_cells)¶
correct the indices in column j in dimension k
assumes column j hasn’t already been corrected assumes val[k][j] has been set, as well as val[k-1] extra_cells maps to duplicate cells
-
inline ZigzagChainComplex()¶
-
template<typename CpxT>
inline ZigzagChainComplex(const ZigzagFiltration<CpxT, T> &X)¶ Construct a zigzag chain complex from a zigzag filtration
constructs a distinct column for every time a cell enters
-
inline size_t maxdim() const¶
return maximum dimension of cells
-
inline size_t dim(const size_t k) const¶
return number of cells in specified dimension
- Parameters
dim – dimension
-
inline size_t dim() const¶
-
inline void _correct_indices(size_t k, size_t j, const std::vector<std::vector<size_t>> extra_cells)¶
Template Struct ZigzagPair¶
Defined in File reduction.hpp
-
template<typename T>
struct bats::zigzag::ZigzagPair¶ Public Functions
-
inline ZigzagPair()¶
-
inline ZigzagPair(const size_t dim, const size_t birth_ind, const size_t death_ind, const T birth, const T death, const bool birth_is_entry, const bool death_is_entry)¶
-
inline bool operator==(const ZigzagPair &other) const¶
-
inline bool operator!=(const ZigzagPair &other) const¶
-
inline size_t get_dim() const¶
-
inline size_t get_birth_ind() const¶
-
inline size_t get_death_ind() const¶
-
inline std::string str()¶
Public Members
-
size_t dim¶
-
size_t birth_ind¶
-
size_t death_ind¶
-
bool birth_is_entry¶
-
bool death_is_entry¶
Friends
- inline friend friend std::ostream & operator<< (std::ostream &os, const ZigzagPair &p)
-
inline ZigzagPair()¶
Template Struct D¶
Defined in File matrix_interface.hpp
public E< Impl >
(Template Struct E)public L< Impl >
(Template Struct L)public U< Impl >
(Template Struct U)
Template Struct E¶
Defined in File matrix_interface.hpp
public A< Impl >
(Template Struct A)
public D< Impl >
(Template Struct D)public EL< Impl >
(Template Struct EL)public ELH< Impl >
(Template Struct ELH)public EU< Impl >
(Template Struct EU)public EUH< Impl >
(Template Struct EUH)public P< Impl >
(Template Struct P)
-
template<typename Impl>
struct E : public A<Impl>¶ Subclassed by D< Impl >, EL< Impl >, ELH< Impl >, EU< Impl >, EUH< Impl >, P< Impl >
Template Struct EL¶
Defined in File matrix_interface.hpp
public E< Impl >
(Template Struct E)public L< Impl >
(Template Struct L)
Template Struct ELH¶
Defined in File matrix_interface.hpp
public E< Impl >
(Template Struct E)public L< Impl >
(Template Struct L)
Template Struct EU¶
Defined in File matrix_interface.hpp
public E< Impl >
(Template Struct E)public U< Impl >
(Template Struct U)
Template Struct EUH¶
Defined in File matrix_interface.hpp
public E< Impl >
(Template Struct E)public U< Impl >
(Template Struct U)
Template Struct is_UnivariatePolynomial< UnivariatePolynomial< T > >¶
Defined in File polynomial.hpp
-
template<typename T>
struct is_UnivariatePolynomial<UnivariatePolynomial<T>> : public true_type¶
Template Struct L¶
Defined in File matrix_interface.hpp
public T< Impl >
(Template Struct T)
public D< Impl >
(Template Struct D)public EL< Impl >
(Template Struct EL)public ELH< Impl >
(Template Struct ELH)
-
template<typename Impl>
struct L : public T<Impl>¶ Subclassed by D< Impl >, EL< Impl >, ELH< Impl >
Struct MAT¶
Defined in File matrix_interface.hpp
public A< Impl >
(Template Struct A)public A< T >
(Template Struct A)
Struct MultiGraph::Edge¶
Defined in File multigraph.hpp
This struct is a nested type of Template Class MultiGraph.
Struct MultiGraph::Node¶
Defined in File multigraph.hpp
This struct is a nested type of Template Class MultiGraph.
Template Struct P¶
Defined in File matrix_interface.hpp
public E< Impl >
(Template Struct E)
Template Struct SmithFact¶
Defined in File pid.hpp
-
template<class TC>
struct SmithFact¶ Public Functions
-
inline ColumnMatrix<TC> prod() const¶
-
inline ColumnMatrix<TC> prod() const¶
Template Struct SparseFact¶
Defined in File sparse_fact.hpp
-
template<class TC>
struct SparseFact¶ Public Functions
-
inline ColumnMatrix<TC> LEUP_prod() const¶
-
inline ColumnMatrix<TC> PLEU_prod() const¶
-
inline ColumnMatrix<TC> UELP_prod() const¶
-
inline ColumnMatrix<TC> PUEL_prod() const¶
-
inline ColumnMatrix<TC> LQU_prod() const¶
-
inline ColumnMatrix<TC> UQL_prod() const¶
-
inline ColumnMatrix<TC> LEUP_prod() const¶
Template Struct T¶
Defined in File matrix_interface.hpp
public A< Impl >
(Template Struct A)
public L< Impl >
(Template Struct L)public U< Impl >
(Template Struct U)
Template Struct U¶
Defined in File matrix_interface.hpp
public T< Impl >
(Template Struct T)
public D< Impl >
(Template Struct D)public EU< Impl >
(Template Struct EU)public EUH< Impl >
(Template Struct EUH)
-
template<typename Impl>
struct U : public T<Impl>¶ Subclassed by D< Impl >, EU< Impl >, EUH< Impl >
Class AbstractMatrix¶
Defined in File abstract_matrix.hpp
public ColumnMatrix< TC >
(Template Class ColumnMatrix)public CSCMatrix< TV, TI >
(Template Class CSCMatrix)
-
class AbstractMatrix¶
Subclassed by ColumnMatrix< TC >, CSCMatrix< TV, TI >
Class CellComplex¶
Defined in File cell_complex.hpp
-
class bats::CellComplex¶
Public Functions
-
inline CellComplex()¶
-
inline CellComplex(size_t maxdim)¶
-
inline size_t maxdim() const¶
-
inline size_t ncells(size_t k) const¶
-
inline size_t ncells() const¶
-
inline size_t add(const std::vector<size_t> &b, const std::vector<int> &c, size_t k)¶
-
inline size_t add_vertex()¶
-
inline size_t add_vertices(size_t k)¶
-
inline ColumnMatrix<SparseVector<int, size_t>> boundary(size_t dim)¶
-
void boundary(size_t k, std::vector<size_t> row, std::vector<size_t> col)¶
-
inline CellComplex()¶
Class CellularMap¶
Defined in File cell_map.hpp
-
class bats::CellularMap¶
Public Functions
-
inline CellularMap()¶
-
inline CellularMap(size_t dim)¶
-
inline CellularMap(std::string &fname)¶
-
template<typename CpxT>
inline CellularMap(const CpxT &X, const CpxT &Y)¶ Construct inclusion map
Should work for both SimplicialComplex and CubicalComplex
-
inline size_t maxdim() const¶
-
inline map_type &operator[](size_t k)¶
-
inline const map_type &operator[](size_t k) const¶
-
inline void save(std::string &fname) const¶
Public Static Functions
-
template<typename CpxT>
static inline CellularMap identity(const CpxT &X)¶
-
inline CellularMap()¶
Class CubicalComplex¶
Defined in File cubical_complex.hpp
-
class bats::CubicalComplex¶
Public Functions
-
inline CubicalComplex()¶
-
inline CubicalComplex(size_t maxdim)¶
-
inline CubicalComplex(size_t n, size_t maxdim)¶
-
inline size_t find_idx(const std::vector<size_t> &s)¶
-
inline size_t find_idx(const std::vector<size_t> &s) const¶
-
inline size_t maxdim() const¶
-
inline size_t ncells(const size_t k) const¶
-
inline size_t ncells() const¶
-
inline void set_dimension(size_t maxdim)¶
-
inline void print_summary() const¶
-
inline auto faces_begin(const size_t dim, const size_t i) const¶
-
inline auto faces_end(const size_t dim, const size_t i) const¶
-
inline auto cell_begin(const size_t dim, const size_t i) const¶
-
inline auto cell_end(const size_t dim, const size_t i) const¶
-
inline void get_cube(size_t dim, size_t i, std::vector<size_t> &s) const¶
-
inline std::vector<size_t> get_cube(size_t dim, size_t i) const¶
-
inline auto get_cell(size_t dim, size_t i, std::vector<size_t> &s) const¶
-
inline auto get_cell(size_t dim, size_t i) const¶
-
inline std::vector<std::vector<size_t>> get_cubes(const size_t dim) const¶
-
inline CubicalComplex skeleton(const size_t k) const¶
-
inline std::vector<std::vector<size_t>> get_cubes() const¶
-
inline void load_cubes(std::string &fname)¶
Public Static Functions
-
static inline CubicalComplex generate_cube(const size_t n)¶
generate a discretized cube on n^3 vertices
- Parameters
n – number of vertex locations along each dimension
-
inline CubicalComplex()¶
Template Class Diagram¶
Defined in File diagram.hpp
-
template<typename NT, typename ET>
class bats::Diagram¶ Public Functions
-
inline Diagram()¶
-
inline Diagram(size_t n, size_t m)¶
-
inline size_t nnode() const¶
-
inline size_t nedge() const¶
-
inline size_t edge_source(size_t j) const¶
-
inline size_t edge_target(size_t j) const¶
-
inline void save_metadata(std::string &fname) const¶
-
inline void save(std::string &dname) const¶
-
struct Edge¶
-
inline Diagram()¶
Template Class Filtration¶
Defined in File filtration.hpp
-
template<typename TF, class CpxT>
class bats::Filtration¶ A filtration which can be used to wrap a simplicial/cubical/cell complex.
A filtration class, templated over the type of the filtration parameter, and the type of the underlying complex
Public Functions
-
inline Filtration()¶
-
template<class ...Ts>
inline Filtration(const Ts (&... args))¶ Initialization which passes arguments to initialize the underlying complex
- Parameters
args... – passed to complex initialization
-
inline Filtration(const CpxT &C, const std::vector<std::vector<TF>> &vals)¶
Initialization which passes arguments to initialize the underlying complex
- Parameters
C – complex
vals – filtration values for every cell in C
-
inline const std::vector<std::vector<TF>> &vals() const¶
return const reference to filtration values
-
inline const std::vector<TF> &vals(const size_t k) const¶
return const reference to filtration values
- Parameters
k – dimension of values to return
-
inline size_t maxdim() const¶
return maximum dimension of cells
-
inline size_t ncells(const size_t dim) const¶
return number of cells in specified dimension
- Parameters
dim – dimension
-
template<class ...Ts>
inline cell_ind add(TF t, Ts (&... args))¶ add cell to filtration
- Parameters
t – filtration parameter
...args – passed to add method of underlying complex
-
template<class ...Ts>
inline std::vector<cell_ind> add_recursive(TF t, Ts (&... args))¶ Add recursively to filtration. Any cells added will take filtration value t.
- Parameters
t – filtration parameter
...args – passed to add_recursive method of underlying complex
-
inline std::vector<size_t> sortperm(size_t dim) const¶
-
inline std::vector<std::vector<size_t>> sortperm() const¶
-
inline Filtration()¶
Class CompositePermutation¶
Defined in File permutation.hpp
-
class bats::future::CompositePermutation¶
Public Functions
-
inline CompositePermutation()¶
-
inline void append(const ElementaryPermutation &p)¶
-
inline void swap(size_t i, size_t j)¶
-
inline CompositePermutation &operator()(const ElementaryPermutation &p)¶
Friends
- friend friend std::ostream & operator<< (std::ostream &os, const CompositePermutation &p)
-
inline CompositePermutation()¶
Template Class const_strided_iterator¶
Defined in File dense.hpp
-
template<typename T>
class bats::future::const_strided_iterator : public std::iterator<std::random_access_iterator_tag, T>¶ Public Functions
-
inline const_strided_iterator()¶
-
inline ~const_strided_iterator()¶
-
inline iterator operator++(int)¶
-
inline iterator &operator++()¶
-
inline iterator operator--(int)¶
-
inline iterator &operator--()¶
-
inline reference operator*() const¶
-
inline pointer operator->() const¶
-
inline bool operator==(const iterator &rhs) const¶
-
inline bool operator!=(const iterator &rhs) const¶
-
inline iterator operator+(size_t i) const¶
-
inline reference operator[](size_t i) const¶
-
inline const_strided_iterator()¶
Template Class Matrix¶
Defined in File dense.hpp
-
template<typename T>
class bats::future::Matrix¶ -
Public Functions
-
inline size_t len() const¶
-
inline Matrix()¶
-
inline Matrix(size_t m, size_t n, ColumnMajor)¶
-
inline Matrix(size_t m, size_t n)¶
-
inline Matrix(Matrix &other, ColumnMajor)¶
-
inline size_t nrow() const¶
-
inline size_t ncol() const¶
-
inline std::pair<size_t, size_t> dims() const¶
-
template<typename I1, typename I2>
inline const MatrixView<T, I1, I2> view(I1 &rows, I2 &cols) const¶
-
template<typename I1, typename I2>
inline const MatrixView<T, I1, I2> view(I1 &&rows, I2 &&cols) const¶
-
inline VectorView<T> row(size_t i)¶
-
inline VectorView<T> column(size_t j)¶
-
inline void print_info() const¶
-
inline void print() const¶
-
inline void swap_rows(size_t i1, size_t i2)¶
-
inline void swap_columns(size_t j1, size_t j2)¶
-
inline bool delete_column()¶
-
inline void add_row(size_t i1, size_t i0)¶
-
inline void add_column(size_t j1, size_t j0)¶
-
inline size_t len() const¶
Template Class MatrixView¶
Defined in File dense.hpp
Template Class range¶
Defined in File dense.hpp
-
template<typename T>
class bats::future::range¶ Public Types
-
typedef const_iterator iterator¶
Public Functions
-
inline range()¶
-
inline size_t size() const¶
-
inline const_iterator const begin()¶
-
inline const_iterator const end()¶
-
inline const_iterator const cbegin()¶
-
inline const_iterator const cend()¶
-
typedef const_iterator iterator¶
Class range::const_iterator¶
Defined in File dense.hpp
This class is a nested type of Template Class range.
-
class bats::future::range::const_iterator : public std::iterator<std::random_access_iterator_tag, T>¶
Public Functions
-
inline const_iterator()¶
-
inline ~const_iterator()¶
-
inline iterator operator++(int)¶
-
inline iterator &operator++()¶
-
inline iterator operator--(int)¶
-
inline iterator &operator--()¶
-
inline reference operator*() const¶
-
inline pointer operator->() const¶
-
inline bool operator==(const iterator &rhs) const¶
-
inline bool operator!=(const iterator &rhs) const¶
-
inline const_iterator()¶
Template Class strided_iterator¶
Defined in File dense.hpp
-
template<typename T>
class bats::future::strided_iterator : public std::iterator<std::random_access_iterator_tag, T>¶ Public Functions
-
inline strided_iterator()¶
-
inline ~strided_iterator()¶
-
inline iterator operator++(int)¶
-
inline iterator &operator++()¶
-
inline iterator operator--(int)¶
-
inline iterator &operator--()¶
-
inline reference operator*() const¶
-
inline pointer operator->() const¶
-
inline bool operator==(const iterator &rhs) const¶
-
inline bool operator!=(const iterator &rhs) const¶
-
inline iterator operator+(size_t i) const¶
-
inline reference operator[](size_t i) const¶
-
inline strided_iterator()¶
Template Class VectorView¶
Defined in File dense.hpp
-
template<typename T>
class bats::future::VectorView¶ Public Types
-
typedef strided_iterator<T> iterator¶
-
typedef const_strided_iterator<T> const_iterator¶
Public Functions
-
inline const_iterator begin() const¶
-
inline const_iterator end() const¶
-
inline const_iterator cbegin() const¶
-
inline const_iterator cend() const¶
-
inline void print() const¶
-
inline void axpy(T a, const VectorView &other)¶
-
inline void axpy(T a, const VectorView &&other)¶
-
typedef strided_iterator<T> iterator¶
Template Class LightSimplicialComplex¶
Defined in File light_simplicial_complex.hpp
-
template<typename index_type = size_t, typename hash_table = std::unordered_map<index_type, size_t>>
class bats::LightSimplicialComplex¶ Public Functions
-
inline index_type max_vertex(index_type s, size_t dim) const¶
-
inline LightSimplicialComplex()¶
-
inline LightSimplicialComplex(const index_type n, const index_type k)¶
-
inline index_type maxdim() const¶
-
inline size_t ncells(size_t dim) const¶
-
inline size_t ncells() const¶
-
inline index_type simplex_key(const std::vector<index_type> &s) const¶
-
inline void key_to_simplex(const size_t dim, index_type key, std::vector<index_type> &s) const¶
-
inline std::vector<index_type> key_to_simplex(const size_t dim, index_type key) const¶
-
inline std::vector<index_type> get_simplex(const size_t dim, const size_t i) const¶
-
inline void get_simplex(const size_t dim, const size_t i, std::vector<index_type> &s) const¶
-
inline auto get_cell(size_t dim, size_t i, std::vector<index_type> &s) const¶
-
inline auto get_cell(size_t dim, size_t i) const¶
-
inline std::vector<std::vector<index_type>> get_simplices(const size_t dim) const¶
-
inline std::vector<std::vector<size_t>> get_simplices() const¶
-
inline size_t find_idx(const size_t dim, const index_type key) const¶
-
inline size_t find_idx(const std::vector<index_type> &s) const¶
-
inline cell_ind add_unsafe(const size_t dim, const index_type k)¶
-
inline cell_ind add(const size_t dim, const index_type k)¶
-
inline cell_ind add_unsafe(const std::vector<index_type> &s)¶
-
inline auto add(const std::vector<index_type> &s)¶
-
inline std::vector<cell_ind> add_recursive(size_t dim, const index_type k)¶
-
inline std::vector<cell_ind> add_recursive(const std::vector<index_type> &s)¶
-
inline auto simplex_begin(const size_t dim, const size_t i) const¶
-
inline auto simplex_end(const size_t dim, const size_t i) const¶
-
inline auto boundary(const size_t dim, const size_t i) const¶
-
inline void print_summary() const¶
-
inline index_type max_vertex(index_type s, size_t dim) const¶
Template Class ReducedChainComplex¶
Defined in File basis.hpp
-
template<typename MT>
class bats::ReducedChainComplex¶ -
Public Functions
-
inline size_t hdim(size_t k) const¶
-
inline size_t betti(size_t k) const¶
-
inline size_t maxdim() const¶
-
inline size_t dim(size_t k) const¶
-
inline void initialize(const ChainComplex<MT> &C)¶
initialize with chain complex C, but do not do reduction
-
inline ReducedChainComplex()¶
-
inline ReducedChainComplex(const ChainComplex<MT> &C)¶
-
template<typename algflag>
inline ReducedChainComplex(const ChainComplex<MT> &C, algflag)¶
-
template<typename algflag>
inline ReducedChainComplex(const ChainComplex<MT> &C, algflag, bats::compute_basis_flag)¶
-
template<typename algflag>
inline ReducedChainComplex(const ChainComplex<MT> &C, algflag, bats::clearing_flag)¶
-
template<typename algflag>
inline ReducedChainComplex(const ChainComplex<MT> &C, algflag, bats::compression_flag)¶
-
template<typename algflag>
inline ReducedChainComplex(const ChainComplex<MT> &C, algflag, bats::compression_flag, bats::compute_basis_flag)¶
-
inline void permute_matrices(size_t k, const std::vector<size_t> &perm)¶
-
template<typename ...Args>
inline void permute_basis(const std::vector<std::vector<size_t>> &perm, Args... args)¶
-
template<typename Information_type, typename ...Args>
inline void update_basis_general(const Information_type &UI, Args... args)¶
-
inline void sparsify_basis()¶
greedily introduce sparsity into basis
-
inline chain_type get_preferred_representative(const size_t j, const size_t k) const¶
-
inline void find_preferred_representative(chain_type &y, const size_t k) const¶
-
inline chain_type chain_preferred_representative(const chain_type &c, size_t k) const¶
-
inline void print_summary(bool print_nnz = false) const¶
-
inline size_t hdim(size_t k) const¶
Template Class ReducedCochainComplex¶
Defined in File cohom_basis.hpp
-
template<typename MT>
class bats::ReducedCochainComplex¶ -
Public Functions
-
inline size_t hdim(size_t k) const¶
-
inline size_t maxdim() const¶
-
inline ReducedCochainComplex()¶
-
inline ReducedCochainComplex(const CochainComplex<MT> &C)¶
-
template<typename algflag>
inline ReducedCochainComplex(const CochainComplex<MT> &C, algflag)¶
-
template<typename algflag>
inline ReducedCochainComplex(const CochainComplex<MT> &C, algflag, bats::compute_basis_flag)¶
-
template<typename algflag>
inline ReducedCochainComplex(const CochainComplex<MT> &C, algflag, bats::clearing_flag)¶
-
template<typename algflag>
inline ReducedCochainComplex(const CochainComplex<MT> &C, algflag, bats::compression_flag)¶
-
inline cochain_type get_preferred_representative(size_t i, const size_t k) const¶
-
inline cochain_type chain_preferred_representative(const cochain_type &c, size_t k) const¶
-
inline size_t hdim(size_t k) const¶
Class SimplicialComplex¶
Defined in File simplicial_complex.hpp
-
class bats::SimplicialComplex¶
A simplicial complex based using a trie data structure.
A class which can be used to hold simplicial complexes on large or exapanding vertex sets. For a lighter-weight option, see LightSimplicialComplex
Public Functions
-
inline SimplicialComplex()¶
-
inline SimplicialComplex(size_t maxdim)¶
Initialization up to a certain dimension
- Parameters
maxdim – [in] - the maximum dimension simplex expected to be added
-
inline SimplicialComplex(size_t n, size_t maxdim)¶
Initialization on a certain vertex
- Parameters
n – [in] - the maximum expected vertex index
maxdim – [in] - the maximum dimension simplex expected to be added
-
inline SimplicialComplex(const std::vector<size_t> &dim)¶
-
inline SimplicialComplex(const std::string &&fname)¶
-
inline size_t find_idx(const std::vector<size_t> &s)¶
Find the index of a simplex
- Parameters
s – [in] A vector containing the simplex
- Returns
The index associated with the simplex. Returns bats::NO_IND if the simplex is not in the complex.
-
inline size_t find_idx(const std::vector<size_t> &s) const¶
-
inline size_t maxdim() const¶
-
inline size_t ncells(const size_t k) const¶
-
inline size_t ncells() const¶
-
inline auto faces_begin(const size_t dim, const size_t i) const¶
-
inline auto faces_end(const size_t dim, const size_t i) const¶
-
inline auto simplex_begin(const size_t dim, const size_t i) const¶
-
inline auto simplex_end(const size_t dim, const size_t i) const¶
-
inline void get_simplex(size_t dim, size_t i, std::vector<size_t> &s) const¶
fill s with simple i in dimension dim
-
inline std::vector<size_t> get_simplex(size_t dim, size_t i) const¶
return simplex i in dimension dim
-
inline auto get_cell(size_t dim, size_t i, std::vector<size_t> &s) const¶
-
inline auto get_cell(size_t dim, size_t i) const¶
-
inline std::vector<std::vector<size_t>> get_simplices(const size_t dim) const¶
-
inline std::vector<std::vector<size_t>> get_simplices() const¶
-
inline void union_add(const SimplicialComplex &Y)¶
-
inline std::vector<size_t> get_indices(const SimplicialComplex &A, size_t dim) const¶
-
inline std::vector<std::vector<size_t>> get_indices(const SimplicialComplex &A) const¶
-
inline auto boundary(const size_t dim, const size_t k) const¶
-
inline ~SimplicialComplex()¶
-
inline void save(std::string &fname) const¶
-
inline void print_summary() const¶
-
inline void print_cells() const¶
Friends
- friend class MorsePairing< SimplicialComplex >
- inline friend friend SimplicialComplex simplicial_union (const SimplicialComplex &X, const SimplicialComplex &Y)
- inline friend friend SimplicialComplex intersection (const SimplicialComplex &X, const SimplicialComplex &Y)
-
inline SimplicialComplex()¶
Template Class SparseTrie¶
Defined in File trie.hpp
-
template<typename A, typename T>
class bats::SparseTrie¶ Public Types
-
typedef SparseTrie<A, T> child_type¶
-
typedef std::unordered_map<A, child_type*> child_container¶
Public Functions
-
inline SparseTrie(const SparseTrie &t)¶
-
inline SparseTrie(SparseTrie &&t)¶
-
inline SparseTrie()¶
-
inline ~SparseTrie()¶
-
inline SparseTrie &operator=(const SparseTrie &t)¶
-
inline SparseTrie &operator=(SparseTrie &&t)¶
-
typedef SparseTrie<A, T> child_type¶
Template Class ZigzagFiltration¶
Defined in File zigzag_filtration.hpp
-
template<typename CpxT, typename T = double>
class bats::zigzag::ZigzagFiltration¶ A class that wraps a complex with a zigzag filtration.
A class that wraps a complex with a right filtration. Cells can have entry times and removal times. These intervals are stored as std::pair<T, T>
Public Functions
-
inline ZigzagFiltration()¶
-
template<class ...Ts>
inline ZigzagFiltration(const Ts (&... args))¶ Initialization which passes arguments to initialize the underlying complex
- Parameters
args... – passed to complex initialization
-
inline ZigzagFiltration(const CpxT &X, const std::vector<std::vector<std::vector<std::pair<T, T>>>> &val)¶
Construct right filtration explicitly on a complex
val should be a vector of vector of pairs. val[k][i] is the pair of entry times for cell i in dimension k in X.
No checks are done to make sure the number of values matches the number of cells
- Parameters
X – complex representing topological space
val – right filtration values for each cell in X
-
inline const std::vector<std::vector<std::vector<std::pair<T, T>>>> &vals() const¶
return const reference to right filtration values
-
inline const std::vector<std::vector<std::pair<T, T>>> &vals(const size_t k) const¶
return const reference to right filtration values
- Parameters
k – dimension of values to return
-
inline size_t maxdim() const¶
return maximum dimension of cells
-
inline size_t ncells(const size_t dim) const¶
return number of cells in specified dimension
- Parameters
dim – dimension
-
template<class ...Ts>
inline cell_ind add(const T entry, const T exit, Ts (&... args))¶ add cell to right filtration
- Parameters
entry – entry parameter
exit – exit parameter
...args – - passed to add method of underlying complex
-
template<class ...Ts>
inline std::vector<cell_ind> add_recursive(const T entry, const T exit, Ts (&... args))¶ Add recursively to right filtration. Any cells added will take same entry and exit parameters
- Parameters
entry – entry parameter
exit – exit parameter
...args – - passed to add_recursive method of underlying complex
-
inline ZigzagFiltration()¶
Template Class ColumnMatrix¶
Defined in File col_matrix.hpp
public AbstractMatrix
(Class AbstractMatrix)
-
template<class TC>
class ColumnMatrix : public AbstractMatrix¶ -
Public Functions
-
inline ColumnMatrix()¶
-
inline ColumnMatrix(size_t m, size_t n)¶
-
template<typename TC2>
inline ColumnMatrix(const ColumnMatrix<TC2> &other)¶
-
inline void read(std::istream &io)¶
-
inline ColumnMatrix(std::istream &io)¶
-
inline ColumnMatrix(std::string &fname)¶
-
inline size_t nrow() const¶
-
inline size_t ncol() const¶
-
inline void set_nrow(size_t mnew)¶
-
inline auto getval(const size_t i, const size_t j) const¶
-
template<class ...Ts>
inline void append_column(Ts (&... args))¶ append a column to the end of the matrix
calls a column vector constructor on arguments passed in.
-
inline void append_row()¶
append an empty row to the end of the matrix
-
template<class ...Ts>
inline void insert_column(const size_t &index, Ts (&&... args))¶ Do not recommend, because if we want to insert multiple columns, the index will change after the first insertion. Thus the important thing we need to assume is the index list are in ascending order!
-
inline void append_column()¶
-
inline void insert_column(const size_t &index)¶
-
inline void insert_columns(const std::vector<size_t> &c_inds, std::vector<TC> &insert_col)¶
insert list of columns at list of specified indices
mutates input inserted columns
-
inline void insert_row(const size_t &index)¶
-
inline void insert_rows(const std::vector<size_t> &r_inds)¶
insert zero rows at specified locations
-
inline void erase_column(const size_t &index)¶
-
inline void erase_column()¶
-
inline void erase_row(const size_t &index)¶
erase specified row
-
inline void erase_row()¶
erase last row
-
inline void erase_row_unsafe()¶
assumes that last row is zero so we only need to decrement number of rows
-
inline auto operator()(size_t i, size_t j) const¶
-
inline bool operator==(const ColumnMatrix &other) const¶
-
inline ColumnMatrix submatrix(const std::vector<size_t> &rind, const std::vector<size_t> &cind) const¶
-
inline ColumnMatrix block(const size_t i0, const size_t i1, const size_t j0, const size_t j1) const¶
-
inline void set_block(const size_t i0, const size_t i1, const size_t j0, const size_t j1, const ColumnMatrix &B)¶
-
inline void clear_rows(const std::vector<bool> &c)¶
clear rows i for which c[i] is true use vector of bools for quick lookup - vector of inds would require search
-
inline void clear_cols(const std::vector<bool> &c)¶
clear columns j for which c[j] is true
frees memory as well
-
inline void swap_rows(const size_t i, const size_t i2)¶
-
inline void mix_rows(const size_t i, const size_t i2, const val_type &a, const val_type &b, const val_type &c, const val_type &d)¶
-
inline ColumnMatrix operator*(const val_type a) const¶
-
inline ColumnMatrix operator*(const ColumnMatrix &B) const¶
-
inline ColumnMatrix operator+(const ColumnMatrix &B) const¶
-
inline ColumnMatrix &operator+=(const ColumnMatrix &B)¶
-
inline ColumnMatrix operator-(const ColumnMatrix &B) const¶
-
inline ColumnMatrix transpose() const¶
-
inline ColumnMatrix T() const¶
-
inline void permute_cols(const std::vector<size_t> &colperm)¶
-
inline void ipermute_cols(const std::vector<size_t> &colperm)¶
-
inline void mix_cols(const size_t j, const size_t k, const val_type &a, const val_type &b, const val_type &c, const val_type &d)¶
-
inline void permute_rows(const std::vector<size_t> &rowperm)¶
-
inline void ipermute_rows(const std::vector<size_t> &rowperm)¶
-
inline void permute(const std::vector<size_t> &rowperm, const std::vector<size_t> &colperm)¶
-
inline ColumnMatrix &J_right_inplace()¶
-
inline ColumnMatrix J_right() const¶
-
inline ColumnMatrix &J_left_inplace()¶
-
inline ColumnMatrix J_left() const¶
-
inline ColumnMatrix &J_conjugation_inplace()¶
-
inline ColumnMatrix J_conjugation() const¶
-
inline void swap_cols(size_t j1, size_t j2)¶
-
inline void schur_complement(size_t i, size_t j)¶
-
inline ColumnMatrix &row_scale(const std::vector<val_type> &coeff)¶
-
inline ColumnMatrix &col_inv_scale(const std::vector<val_type> &coeff)¶
-
inline size_t nnz() const¶
-
inline bool is_zero() const¶
-
inline bool is_upper() const¶
-
inline bool is_upper_invert() const¶
-
inline bool is_lower() const¶
-
inline bool is_reduced() const¶
-
inline bool is_pivot_matrix() const¶
-
inline bool is_EL() const¶
-
inline bool is_EU() const¶
-
inline bool is_ELhat() const¶
-
inline bool is_EUhat() const¶
-
inline void print_size() const¶
-
inline void print() const¶
-
inline void write(std::ostream &io) const¶
-
inline std::string str()¶
-
inline void save(std::string &fname) const¶
Public Static Functions
-
static inline ColumnMatrix identity(size_t n)¶
-
static inline ColumnMatrix random(size_t m, size_t n, double p, int maxval, std::default_random_engine &generator)¶
-
static inline ColumnMatrix random(size_t m, size_t n, double p, int maxval)¶
Friends
- inline friend friend TC operator* (const TC &x, const ColumnMatrix &A)
multiplication x^T A
- inline friend friend ColumnMatrix tensor_product (const ColumnMatrix &A, const ColumnMatrix &B)
- inline friend friend ColumnMatrix direct_sum (const ColumnMatrix &A, const ColumnMatrix &B)
-
inline ColumnMatrix()¶
Template Class CSCMatrix¶
Defined in File csc_matrix.hpp
public AbstractMatrix
(Class AbstractMatrix)
-
template<typename TV, typename TI = size_t>
class CSCMatrix : public AbstractMatrix¶ Public Functions
-
inline CSCMatrix()¶
-
inline CSCMatrix(size_t m, size_t n, const std::vector<TI> &colptr, const std::vector<TI> &rowind, const std::vector<TV> &val)¶
-
inline CSCMatrix(const std::vector<TI> &colptr, const std::vector<TI> &rowind, const std::vector<TV> &val)¶
-
inline size_t nrow() const¶
-
inline size_t ncol() const¶
-
inline void print_size() const¶
-
inline void print(size_t rowmin, size_t rowmax, size_t colmin, size_t colmax) const¶
-
inline void print() const¶
Friends
- inline friend friend void block_select (const CSCMatrix &M, const std::vector< size_t > &cind, const std::vector< size_t > &prow, const size_t m, CSCMatrix &A)
- template<size_t N> inline friend friend void block_select (const CSCMatrix &M, const std::vector< size_t > &cind, const std::vector< size_t > *(&&prow)[N], const size_t(&&m)[N], CSCMatrix *(&&A)[N])
- inline friend friend void gemm (const CSCMatrix &A, const CSCMatrix &B, CSCMatrix &C)
- inline friend friend void sum (const CSCMatrix &A, const CSCMatrix &B, CSCMatrix &C)
- inline friend friend void sum (const TV &alpha, const CSCMatrix &A, const CSCMatrix &B, CSCMatrix &C)
- inline friend friend void trilu (const CSCMatrix &A, const CSCMatrix &B, CSCMatrix &C)
-
inline CSCMatrix()¶
Template Class ModP¶
Defined in File field.hpp
public AbstractField< ModP< IntT, P > >
(Template Class AbstractField)
-
template<typename IntT, unsigned P>
class ModP : public AbstractField<ModP<IntT, P>>¶ Public Functions
-
inline ModP()¶
-
inline bool operator==(const int b) const¶
-
inline bool operator!=(const int b) const¶
-
inline bool iszero() const¶
Friends
- inline friend friend std::ostream & operator<< (std::ostream &os, const ModP &x)
-
inline ModP()¶
Template Class ModP< IntT, 2 >¶
Defined in File field.hpp
public AbstractField< ModP< IntT, 2 > >
(Template Class AbstractField)
-
template<typename IntT>
class ModP<IntT, 2> : public AbstractField<ModP<IntT, 2>>¶ Public Functions
-
inline ModP()¶
-
inline bool operator==(const int b) const¶
-
inline bool operator!=(const int b) const¶
-
inline bool iszero() const¶
Friends
- inline friend friend std::ostream & operator<< (std::ostream &os, const ModP &x)
-
inline ModP()¶
Template Class MorsePairing¶
Defined in File pairing.hpp
-
template<class CpxT>
class MorsePairing¶ Public Functions
-
inline MorsePairing()¶
-
inline MorsePairing(size_t maxdim)¶
-
inline MorsePairing(std::vector<size_t> ncells)¶
-
inline void clear()¶
-
inline size_t maxdim() const¶
-
inline size_t size(const size_t dim) const¶
-
inline size_t ncells(const size_t dim) const¶
-
inline bool is_paired(size_t dim, size_t i) const¶
-
inline bool set_pair(size_t dim, size_t i, size_t j)¶
-
inline bool set_pair_edge(const size_t i, const size_t j, const size_t ei)¶
-
template<typename TR>
inline bool set_pair_edge(const size_t i, const size_t j, const size_t ei, const std::vector<TR> &rank)¶
-
inline const std::vector<size_t> &up_paired(size_t dim) const¶
-
inline const std::vector<size_t> &down_paired(size_t dim) const¶
-
inline std::vector<size_t> unpaired(size_t dim) const¶
Friends
- friend class Filtration
-
inline MorsePairing()¶
Template Class Rational¶
Defined in File field.hpp
public AbstractField< Rational< IntT > >
(Template Class AbstractField)
-
template<typename IntT>
class Rational : public AbstractField<Rational<IntT>>¶ Public Functions
-
inline Rational()¶
-
inline bool operator==(const int b) const¶
-
inline bool operator!=(const int b) const¶
-
inline bool iszero() const¶
Friends
- inline friend friend std::ostream & operator<< (std::ostream &os, const Rational &x)
-
inline Rational()¶
Template Class SetVector¶
Defined in File set_vector.hpp
-
template<typename TV, typename TI = size_t>
class SetVector¶ Public Functions
-
inline SetVector()¶
-
inline SetVector(const std::set<key_type> indval)¶
-
inline auto nzbegin() const¶
-
inline auto nzend() const¶
-
inline auto nzbegin()¶
-
inline auto nzend()¶
-
inline size_t nnz() const¶
-
inline auto set(const key_type &k)¶
-
inline const key_type &lastnz() const¶
-
inline void permute(const std::vector<size_t> &perm)¶
-
template<class SVT>
inline void axpy(const TV &a, const SVT &x, const TI &firstind, const TI &lastind)¶
-
inline void print() const¶
-
inline void print_row() const¶
-
inline SetVector()¶
Template Class SparseVector¶
Defined in File sparse_vector.hpp
-
template<typename TV, typename TI = size_t>
class SparseVector¶ -
Public Functions
-
inline void sort()¶
-
inline SparseVector()¶
-
inline SparseVector(const std::vector<key_type> &indval)¶
-
template<typename TI2>
inline SparseVector(const SparseVector<int, TI2> &other)¶
-
inline SparseVector(const std::vector<std::tuple<size_t, int>> &ival)¶
-
inline SparseVector(std::initializer_list<TI> ind, std::initializer_list<TV> val)¶
constructor for initializer lists
- Parameters
ind – nonzero indices
val – nonzero values
-
inline SparseVector(std::string &line)¶
-
inline SparseVector shift_inds(TI shift) const¶
-
template<typename T>
inline SparseVector operator[](const T &indset) const¶
-
inline auto nzbegin() const¶
-
inline auto nzend() const¶
-
inline auto nzbegin()¶
-
inline auto nzend()¶
-
inline void clear()¶
-
inline void clear_dealloc()¶
-
inline void clear_zeros()¶
-
inline void clear_inds(const std::vector<bool> &c)¶
clear indices marked true in c i.e. remove entry i if c[i] is true
-
inline void clear_inds(const std::vector<bool> &c, std::vector<key_type> &tmp)¶
-
inline size_t nnz() const¶
-
inline std::vector<size_t> nzinds() const¶
-
inline auto emplace_back(const key_type &k)¶
-
inline const key_type &lastnz() const¶
-
inline const key_type &firstnz() const¶
-
inline void permute(const std::vector<size_t> &perm)¶
-
inline void ipermute(const std::vector<size_t> &perm)¶
-
inline SparseVector subvector(const std::vector<size_t> &pind) const¶
-
inline SparseVector block(const size_t i0, const size_t i1) const¶
-
inline void set_block(const size_t i0, const size_t i1, const SparseVector &b)¶
-
inline void J(const size_t m)¶
-
inline void swap_rows(const size_t i, const size_t j)¶
-
inline void mix_rows(const size_t i, const size_t j, const TV &a, const TV &b, const TV &c, const TV &d)¶
-
inline void insert_rows(const std::vector<size_t> &r_inds)¶
insert row indices at specified locations assumes that list of rows is in sorted order
-
template<class SVT>
inline size_t nnz_intersection(const SVT &x) const¶ calculate the number of non-zeros common to two vectors
- Parameters
x – sparse vector for comparison
- Returns
ct number of non-zeros common to both this vector and x
-
template<class SVT>
inline void coeff_intersection(const SVT &x, std::map<TV, size_t> &ct) const¶ calculate the number of non-zeros common with c * x where c ranges over any possible value
- Parameters
x – sparse vector for comparison
ct – map from coefficient c to number of identical nonzeros with c*x ct is not cleared in the function.
-
inline SparseVector operator+(const SparseVector &other) const¶
-
inline SparseVector operator*(const TV a) const¶
scalar multiplication
-
inline TV operator*(const SparseVector &x) const¶
dot product
-
template<class SVT>
inline void axpy(const TV &a, const SVT &x, const TI &firstind, const TI &lastind, std::vector<key_type> &tmp)¶
-
template<class SVT>
inline void axpy(const SVT &x, const std::vector<TV> &coeff, const std::vector<TI> &inds, std::vector<key_type> &tmp)¶
-
inline SparseVector scale(const TV c) const¶
-
inline void print() const¶
-
inline void print_row() const¶
-
inline std::string str()¶
-
inline SparseVector kron(const SparseVector &other, size_t m) const¶
-
inline SparseVector tensor(const SparseVector &other, size_t m) const¶
Public Static Functions
-
static inline SparseVector random(size_t n, double p, int maxval, std::default_random_engine &generator)¶
-
static inline SparseVector random(size_t n, double p, int maxval)¶
-
inline void sort()¶
Template Class UnivariatePolynomial¶
Defined in File polynomial.hpp
-
template<typename T>
class UnivariatePolynomial¶ Public Functions
-
inline UnivariatePolynomial()¶
-
inline bool is_zero() const¶
-
inline size_t dim() const¶
-
inline size_t degree() const¶
-
inline size_t size() const¶
-
template<typename TC>
inline TC operator()(const ColumnMatrix<TC> &A, const TC &v) const¶
-
inline UnivariatePolynomial operator-() const¶
-
inline UnivariatePolynomial operator+(const UnivariatePolynomial &other) const¶
-
inline UnivariatePolynomial &operator+=(const UnivariatePolynomial &other)¶
-
inline UnivariatePolynomial &operator-=(const UnivariatePolynomial &other)¶
-
inline UnivariatePolynomial operator-(const UnivariatePolynomial &other) const¶
-
inline UnivariatePolynomial operator*(const UnivariatePolynomial &other) const¶
-
inline std::tuple<UnivariatePolynomial, UnivariatePolynomial> divrem(const UnivariatePolynomial &other) const¶
-
inline UnivariatePolynomial operator/(const UnivariatePolynomial &other) const¶
-
inline UnivariatePolynomial remainder(const UnivariatePolynomial &other) const¶
-
inline bool operator==(const UnivariatePolynomial &other) const¶
-
inline bool operator!=(const UnivariatePolynomial &other) const¶
-
inline UnivariatePolynomial gcd(const UnivariatePolynomial &other) const¶
-
inline bool is_monic() const¶
-
inline ColumnMatrix<SparseVector<T>> companion_matrix() const¶
-
inline void print()¶
Public Static Functions
-
static inline UnivariatePolynomial identity()¶
-
static inline UnivariatePolynomial zero()¶
-
static inline UnivariatePolynomial monomial(size_t d, T scale = T(1))¶
Friends
- inline friend friend std::ostream & operator<< (std::ostream &os, const UnivariatePolynomial &p)
-
inline UnivariatePolynomial()¶
Functions¶
Template Function bats::__FilteredChainComplex¶
Defined in File filtered_chain_complex.hpp
Template Function bats::__ReducedFilteredChainComplex¶
Defined in File filtered_basis.hpp
Template Function bats::add_dimension_recursive_flag(Filtration<T, CpxT>&, const NT&, const size_t, const size_t, const std::vector<size_t>&, std::vector<size_t>&, const T&)¶
Defined in File flag.hpp
Template Function bats::add_dimension_recursive_flag(Filtration<T, CpxT>&, const NT&, const size_t, const size_t, const std::vector<size_t>&, std::vector<size_t>&, const T&, bool, const cell_ind&)¶
Defined in File flag.hpp
Template Function bats::add_dimension_recursive_flag(CpxT&, const NT&, const size_t, const size_t, const std::vector<size_t>&, std::vector<size_t>&)¶
Defined in File flag.hpp
Template Function bats::add_dimension_recursive_flag_extension¶
Defined in File flag.hpp
-
template<typename CpxT, typename T, typename NT>
void bats::add_dimension_recursive_flag_extension(Filtration<T, CpxT> &F, const NT &nbrs, const size_t d, const size_t maxd, const std::vector<size_t> &iter_idxs, std::vector<size_t> &spx_idxs, const T &t, const size_t index_of_edge, std::vector<std::vector<size_t>> &inds)¶
Template Function bats::add_dimension_recursive_flag_unsafe¶
Defined in File flag.hpp
Function bats::add_dimension_recursive_nerve¶
Defined in File nerve.hpp
-
void bats::add_dimension_recursive_nerve(SimplicialComplex &N, std::vector<size_t> spx, const bats::Cover &cover, std::vector<size_t> intersection, const size_t dmax)¶
Function bats::all_pairs¶
Defined in File rips.hpp
Template Function bats::barcode(const Diagram<NT, TM>&, size_t)¶
Defined in File sparse.hpp
Template Function bats::barcode(const Diagram<NT, TM>&, size_t, flags::divide_conquer)¶
Defined in File sparse.hpp
Template Function bats::barcode(const Diagram<NT, TM>&, size_t, flags::leftward)¶
Defined in File sparse.hpp
Template Function bats::barcode(const Diagram<NT, TM>&, size_t, flags::rightward)¶
Defined in File sparse.hpp
Template Function bats::barcode(const Diagram<NT, std::vector<TM>>&, Args …)¶
Defined in File sparse.hpp
Template Function bats::barcode_equality¶
Defined in File barcode.hpp
-
template<typename T>
bool bats::barcode_equality(const std::vector<PersistencePair<T>> &ps1, const std::vector<PersistencePair<T>> &ps2)¶
Function bats::bars_to_pairs¶
Defined in File sparse.hpp
-
std::vector<PersistencePair<size_t>> bats::bars_to_pairs(const std::vector<bar> &bars, size_t hdim)¶
Function bats::bivariate_cover¶
Defined in File cover.hpp
Template Function bats::Chain(const CellularMap&, T)¶
Defined in File chain_map.hpp
-
template<typename T>
inline auto bats::Chain(const CellularMap &F, T)¶
Template Function bats::Chain(const Filtration<FT, CpxT>&, T)¶
Defined in File filtered_chain_complex.hpp
Template Function bats::Chain(const Diagram<CpxT, CellularMap>&, T)¶
Defined in File functors.hpp
Template Function bats::ChainFunctor(const DT&)¶
Defined in File functors.hpp
Template Function bats::CompleteFlagFiltration¶
Defined in File flag.hpp
-
template<typename T>
std::tuple<SimplicialComplex, Filtration<T, SimplicialComplex>> bats::CompleteFlagFiltration(const std::vector<size_t> &edges, const std::vector<T> &t, const size_t n, const size_t maxdim, const T t0)¶
Function bats::Cube(size_t, size_t)¶
Defined in File grid.hpp
-
CubicalComplex bats::Cube(size_t m, size_t n)¶
Cubical complex on 2-dimensional gird on m x n vertices
Function bats::Cube(size_t, size_t, size_t)¶
Defined in File grid.hpp
-
CubicalComplex bats::Cube(size_t n1, size_t n2, size_t n3)¶
Cubical complex on 3-dimensional gird on n1 x n2 x n3 vertices
Function bats::Cube(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t)¶
Defined in File grid.hpp
-
CubicalComplex bats::Cube(size_t n1, size_t n2, size_t n3, size_t i0, size_t i1, size_t j0, size_t j1, size_t k0, size_t k1)¶
Subset of Cubical complex of 3-dimensional grid on n1 x n2 x n3 vertices
This function is useful for constructing zigzags through a grid
- Parameters
n1 – grid size in 1st index
n2 – grid size in 2nd index
n3 – grid size in 3rd index
i0 – start of first index
i1 – end of first index
j0 – start of second index
j1 – end of second index
k0 – start of third index
k1 – end of third index
Function bats::CubicalMap¶
Defined in File cubical_map.hpp
-
inline CellularMap bats::CubicalMap(const CubicalComplex &X, const CubicalComplex &Y)¶
Template Function bats::DGLinearFunctor¶
Defined in File functors.hpp
-
template<typename TM, typename DT>
Diagram<DGVectorSpace<TM>, DGLinearMap<TM>> bats::DGLinearFunctor(const DT &D, int degree = -1)¶ Functor from topological category to category of differential graded vector spaces
Chain functor is degree = -1 (default) Cochain functor is degree = +1. This is contravariant (reverses arrows)
Template Function bats::DiscreteMorozovZigzag¶
Defined in File zigzag_zoo.hpp
-
template<typename T, typename M>
std::tuple<Diagram<SimplicialComplex, CellularMap>, std::vector<T>> bats::DiscreteMorozovZigzag(const DataSet<T> &D, const M &dist, T rho, size_t dmax)¶
Template Function bats::dowker_filtration_edges¶
Defined in File dowker_cover.hpp
Template Function bats::DowkerFiltration(const Matrix<T>&, T, size_t)¶
Defined in File dowker.hpp
-
template<typename T>
Filtration<T, SimplicialComplex> bats::DowkerFiltration(const Matrix<T> &pdist, T rmax, size_t dmax)¶
Template Function bats::DowkerFiltration(const DataSet<T>&, const DataSet<T>&, const M&, T, size_t)¶
Defined in File dowker.hpp
Template Function bats::DowkerFiltration(const Matrix<T>&, const bats::Cover&, T, size_t)¶
Defined in File dowker_cover.hpp
-
template<typename T>
Filtration<T, SimplicialComplex> bats::DowkerFiltration(const Matrix<T> &pdist, const bats::Cover &cover, T rmax, size_t dmax)¶
Template Function bats::DowkerFiltration(const DataSet<T>&, const DataSet<T>&, const M&, const bats::Cover&, T, size_t)¶
Defined in File dowker_cover.hpp
Template Function bats::EilenbergZilber(const CpxT&, const CpxT&, const CpxT&, const CpxT&, const size_t, T)¶
Defined in File eilenberg_zilber.hpp
Function bats::extension_perm¶
Defined in File permutation.hpp
Template Function bats::extract_basis_indices(const MT&, const std::vector<size_t>&)¶
Defined in File reduction.hpp
Template Function bats::extract_basis_indices(const MT&)¶
Defined in File reduction.hpp
Function bats::filtration_iperm¶
Defined in File filtration.hpp
Template Function bats::filtration_sortperm(const std::vector<T>&)¶
Defined in File filtration.hpp
Template Function bats::filtration_sortperm(const std::vector<std::vector<T>>&)¶
Defined in File filtration.hpp
Template Function bats::find_perm_from_vector¶
Defined in File permutation.hpp
Template Function bats::flag_filtration_edges¶
Defined in File dowker.hpp
Template Function bats::FlagComplex¶
Defined in File flag.hpp
Template Function bats::FlagFiltration¶
Defined in File flag.hpp
-
template<typename CpxT, typename T>
Filtration<T, CpxT> bats::FlagFiltration(std::vector<filtered_edge<T>> &edges, const size_t n, const size_t maxdim, const T t0)¶
Template Function bats::FlagFiltration_extension¶
Defined in File flag.hpp
-
template<typename CpxT, typename T>
auto bats::FlagFiltration_extension(std::vector<filtered_edge<T>> &edges, const size_t n, const size_t maxdim, const T t0)¶
Template Function bats::Freudenthal(size_t, size_t)¶
Defined in File grid.hpp
Template Function bats::Freudenthal(size_t, size_t, size_t)¶
Defined in File grid.hpp
-
template<typename CpxT>
CpxT bats::Freudenthal(size_t n1, size_t n2, size_t n3)¶ Freudenthal triangulation of 3-dimensional grid on n1 x n2 x n3 vertices
The grid is indexed in row-major order. The index for vertex
(i,j,k)
isk + n2 * (j + n1 * i)
- Parameters
n1 – grid size in 1st index
n2 – grid size in 2nd index
n3 – grid size in 3rd index
Template Function bats::Freudenthal(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t)¶
Defined in File grid.hpp
-
template<typename CpxT>
CpxT bats::Freudenthal(size_t n1, size_t n2, size_t n3, size_t i0, size_t i1, size_t j0, size_t j1, size_t k0, size_t k1)¶ Subset of Freudenthal triangulation of 3-dimensional grid on n1 x n2 x n3 vertices
The grid is indexed in row-major order. The index for vertex
(i,j,k)
isk + n2 * (j + n1 * i)
This function is useful for constructing zigzags through a grid
- Parameters
n1 – grid size in 1st index
n2 – grid size in 2nd index
n3 – grid size in 3rd index
i0 – start of first index
i1 – end of first index
j0 – start of second index
j1 – end of second index
k0 – start of third index
k1 – end of third index
Template Function bats::Freudenthal(const CubicalComplex&, size_t, size_t, size_t)¶
Defined in File grid.hpp
-
template<typename CpxT>
CpxT bats::Freudenthal(const CubicalComplex &X, size_t n1, size_t n2, size_t n3)¶ Freudenthal Triangulation of CubicalComplex
- Parameters
X – cubical complex
n1 – 1st dimension grid size
n2 – 2nd dimension grid size
n3 – 3rd dimension grid size
Template Function bats::future::find_pivot_complete¶
Defined in File lu.hpp
Template Function bats::future::find_pivot_high(const RandomAccessIterator&, ssize_t, ssize_t)¶
Defined in File util.hpp
-
template<typename RandomAccessIterator>
ssize_t bats::future::find_pivot_high(const RandomAccessIterator &v, ssize_t start, ssize_t end)¶
Template Function bats::future::find_pivot_high(const RandomAccessIterator&, ssize_t)¶
Defined in File util.hpp
-
template<typename RandomAccessIterator>
inline ssize_t bats::future::find_pivot_high(const RandomAccessIterator &v, ssize_t end)¶
Function bats::future::operator<<(std::ostream&, const ElementaryPermutation&)¶
Defined in File permutation.hpp
-
std::ostream &bats::future::operator<<(std::ostream &os, const ElementaryPermutation &p)¶
Function bats::future::operator<<(std::ostream&, const CompositePermutation&)¶
Defined in File permutation.hpp
-
std::ostream &bats::future::operator<<(std::ostream &os, const CompositePermutation &p)¶
Function bats::gen_cylinder¶
Defined in File data_gen.hpp
Function bats::get_clearing_inds¶
Defined in File reduction.hpp
Template Function bats::get_compression_inds¶
Defined in File reduction.hpp
-
template<class TVec>
std::vector<bool> bats::get_compression_inds(const ColumnMatrix<TVec> &R)¶
Template Function bats::get_dM_ZZ_inds¶
Defined in File zigzag_zoo.hpp
-
template<typename T>
std::vector<size_t> bats::get_dM_ZZ_inds(const std::vector<T> &hds, const T rho, const T theta)¶ determine set of indices to use for dM-ZZ construction
- Parameters
hds – hausdorff distance of each point to point set. assume in decreasing order.
rho – rips multiplier - should be >10 [OS15 thm 4.6]
theta – depends on dimension of data. In [0.5, 1/sqrt(2))[OS15 eq. 1]
if unsure, set to 0.5 for finer discretization
Template Function bats::greedy_landmarks_hausdorff(const DataSet<T>&, const M&, const size_t)¶
Defined in File landmark.hpp
Template Function bats::Hom(const Diagram<ChainComplex<TM>, ChainMap<TM>>&, size_t)¶
Defined in File functors.hpp
Template Function bats::Hom(const Diagram<ChainComplex<TM>, ChainMap<TM>>&, bool)¶
Defined in File functors.hpp
-
template<typename TM>
Diagram<ReducedChainComplex<TM>, std::vector<TM>> bats::Hom(const Diagram<ChainComplex<TM>, ChainMap<TM>> &D, bool topd = false)¶ Homology functor in all dimensions template over matrix type
when topd is true, a k-dimensional Chain complex will be assumed to be 0 in dimension k+1 and H_k will be computed.
Assumes that all chain complexes have same dimension.
- Parameters
D – diagram of ChainComplexes and ChainMaps
topd – (optional, default: false) if true will compute top dimensional homology.
Template Function bats::Hom(const Diagram<DGVectorSpace<TM>, DGLinearMap<TM>>&, size_t)¶
Defined in File functors.hpp
-
template<typename TM>
Diagram<ReducedDGVectorSpace<TM>, TM> bats::Hom(const Diagram<DGVectorSpace<TM>, DGLinearMap<TM>> &D, size_t k)¶ Homology functor for dimension k template over matrix type
Function bats::identity_perm¶
Defined in File permutation.hpp
Template Function bats::induced_map(const ChainMap<ColumnMatrix<TVec>>&, const ReducedChainComplex<ColumnMatrix<TVec>>&, const ReducedChainComplex<ColumnMatrix<TVec>>&, size_t)¶
Defined in File induced_map.hpp
-
template<class TVec>
ColumnMatrix<TVec> bats::induced_map(const ChainMap<ColumnMatrix<TVec>> &F, const ReducedChainComplex<ColumnMatrix<TVec>> &C, const ReducedChainComplex<ColumnMatrix<TVec>> &D, size_t k)¶
Template Function bats::induced_map(const ChainMap<ColumnMatrix<TVec>>&, const ReducedCochainComplex<ColumnMatrix<TVec>>&, const ReducedCochainComplex<ColumnMatrix<TVec>>&, size_t)¶
Defined in File induced_map.hpp
-
template<class TVec>
ColumnMatrix<TVec> bats::induced_map(const ChainMap<ColumnMatrix<TVec>> &F, const ReducedCochainComplex<ColumnMatrix<TVec>> &C, const ReducedCochainComplex<ColumnMatrix<TVec>> &D, size_t k)¶ obtain induced map on cohomology for dimension k
We assume that F is a chain map, so it is dualized before computing the map
- Parameters
F – ChainMap
C – ReducedCoChainComplex
D – ReducedCoChainComplex k dimension
Template Function bats::induced_map(const DGLinearMap<ColumnMatrix<TVec>>&, const ReducedDGVectorSpace<ColumnMatrix<TVec>>&, const ReducedDGVectorSpace<ColumnMatrix<TVec>>&, size_t)¶
Defined in File induced_map.hpp
-
template<class TVec>
ColumnMatrix<TVec> bats::induced_map(const DGLinearMap<ColumnMatrix<TVec>> &F, const ReducedDGVectorSpace<ColumnMatrix<TVec>> &C, const ReducedDGVectorSpace<ColumnMatrix<TVec>> &D, size_t k)¶ obtain induced map on cohomology for dimension k
We assume that F is a chain map, so it is dualized before computing the map
- Parameters
F – ChainMap
C – ReducedCoChainComplex
D – ReducedCoChainComplex k dimension
Template Function bats::is_left_arrow¶
Defined in File sparse.hpp
Template Function bats::kron_homology¶
Defined in File eilenberg_zilber.hpp
-
template<typename ReducedCpx>
auto bats::kron_homology(const size_t dx, const ReducedCpx &RX, const size_t dy, const ReducedCpx &RY, const ReducedCpx &RXRY)¶
Function bats::linear_cover_intersection_diagram¶
Defined in File inclusion.hpp
Function bats::linear_subset_union_diagram¶
Defined in File inclusion.hpp
Template Function bats::LowerStarFiltration¶
Defined in File star.hpp
Template Function bats::neighborhood(const VectorView<T>&, const DataSet<T>&, const M&, const size_t)¶
Defined in File neighborhood.hpp
Template Function bats::neighborhoods(const DataSet<T>&, const DataSet<T>&, const M&, const T)¶
Defined in File neighborhood.hpp
Template Function bats::neighborhoods(const DataSet<T>&, const DataSet<T>&, const M&, const size_t)¶
Defined in File neighborhood.hpp
Function bats::Nerve(const Diagram<bats::Cover, std::vector<size_t>>&, const size_t)¶
Defined in File functors.hpp
-
Diagram<SimplicialComplex, CellularMap> bats::Nerve(const Diagram<bats::Cover, std::vector<size_t>> &D, const size_t dmax)¶
Function bats::Nerve(const bats::Cover&, const size_t)¶
Defined in File nerve.hpp
-
SimplicialComplex bats::Nerve(const bats::Cover &cover, const size_t dmax)¶
Template Function bats::OscillatingRipsZigzagSets¶
Defined in File zigzag_zoo.hpp
-
template<typename T, typename M>
std::tuple<Diagram<std::set<size_t>, std::vector<size_t>>, std::vector<T>> bats::OscillatingRipsZigzagSets(const DataSet<T> &D, const M &dist, T rho, T eta)¶ Construct diagram of sets with a vector of Rips parameters
Creates this for Oscillating Rips Zigzag construction
Ref Oudot-Sheehy ‘15
- Parameters
D – data set
dist – metric
rho – multiplier
eta – multiplier. Must have eta <= rho
Template Function bats::partial_reduce_parallel(ColumnMatrix<TVec>&, const size_t)¶
Defined in File parallel.hpp
-
template<typename TVec>
void bats::partial_reduce_parallel(ColumnMatrix<TVec> &M, const size_t block_size)¶ do an initial parallel sweep to zero out columns as possible
- Parameters
M – matrix to reduce
block_size – size of column blocks to be processed in parallel
Template Function bats::partial_reduce_parallel(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, const size_t)¶
Defined in File parallel.hpp
-
template<typename TVec>
void bats::partial_reduce_parallel(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, const size_t block_size)¶ do an initial parallel sweep to zero out columns as possible
- Parameters
M – matrix to reduce
U – change of basis
block_size – size of column blocks to be processed in parallel
Template Function bats::pass_L_left¶
Defined in File sparse.hpp
Template Function bats::pass_P_left¶
Defined in File sparse.hpp
Template Function bats::pass_P_right¶
Defined in File sparse.hpp
Template Function bats::pass_PL_left¶
Defined in File sparse.hpp
Template Function bats::pass_U_right¶
Defined in File sparse.hpp
Template Function bats::pass_UP_right¶
Defined in File sparse.hpp
Function bats::perm_to_the_end(const size_t&, const size_t&)¶
Defined in File permutation.hpp
Function bats::perm_to_the_end(const std::vector<size_t>&, const size_t&)¶
Defined in File permutation.hpp
Template Function bats::print_1D_vectors¶
Defined in File print.hpp
Template Function bats::print_2D_vectors¶
Defined in File print.hpp
Template Function bats::print_filtration_info¶
Defined in File print.hpp
-
template<class Filtration>
void bats::print_filtration_info(const Filtration &F)¶
Template Function bats::print_simplex¶
Defined in File print.hpp
Function bats::prod_ind¶
Defined in File simplicial_complex.hpp
Template Function bats::product_paths(CpxT&, itT, const itT, itT, const itT, std::vector<size_t>&, const size_t)¶
Defined in File simplicial_complex.hpp
Template Function bats::product_paths(CpxT&, itT, const itT, itT, const itT, std::vector<size_t>&, const size_t, std::vector<cell_ind>&)¶
Defined in File simplicial_complex.hpp
Template Function bats::Reduce(const ChainComplex<MT>&, Args …)¶
Defined in File basis.hpp
-
template<typename MT, typename ...Args>
inline auto bats::Reduce(const ChainComplex<MT> &C, Args... args)¶
Template Function bats::Reduce(const Filtration<FT, CpxT>&, T, Args …)¶
Defined in File filtered_basis.hpp
Template Function bats::Reduce(const FilteredChainComplex<T, MT>&, Args …)¶
Defined in File filtered_basis.hpp
Template Function bats::reduce_block_dq(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, const size_t, const size_t, const size_t)¶
Defined in File parallel.hpp
-
template<typename TVec>
std::tuple<std::unordered_map<size_t, size_t>, std::vector<size_t>> bats::reduce_block_dq(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, const size_t j0, const size_t j1, const size_t max_block_size)¶ reduce a block of columns via divide and conquer
- Parameters
M – matrix to be reduced
U – change of basis matrix
j0 – start of column range
j1 – upper bound of column range
max_block_size – maximum block size for sequential base case
- Returns
p2c map from pivots to columns for this block
- Returns
nzcol vector of nonzero columns after reduction
Template Function bats::reduce_block_dq(ColumnMatrix<TVec>&, const size_t, const size_t, const size_t, const size_t, const size_t)¶
Defined in File parallel.hpp
-
template<typename TVec>
std::tuple<std::unordered_map<size_t, size_t>, std::vector<size_t>> bats::reduce_block_dq(ColumnMatrix<TVec> &M, const size_t j0, const size_t j1, const size_t max_block_size, const size_t level, const size_t max_depth)¶ reduce a block of columns via divide and conquer
- Parameters
M – matrix to be reduced
j0 – start of column range
j1 – upper bound of column range
max_block_size – maximum block size for sequential base case
- Returns
p2c map from pivots to columns for this block
- Returns
nzcol vector of nonzero columns after reduction
Template Function bats::reduce_block_sequential(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, const size_t, const size_t)¶
Defined in File parallel.hpp
-
template<typename TVec>
std::tuple<std::unordered_map<size_t, size_t>, std::vector<size_t>> bats::reduce_block_sequential(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, const size_t j0, const size_t j1)¶ reduce a block of columns sequentially
- Parameters
M – matrix to be reduced
U – change of basis matrix
j0 – start of column range
j1 – upper bound of column range
- Returns
p2c map from pivots to columns for this block
- Returns
nzcol vector of nonzero columns after reduction
Template Function bats::reduce_block_sequential(ColumnMatrix<TVec>&, const size_t, const size_t)¶
Defined in File parallel.hpp
-
template<typename TVec>
std::tuple<std::unordered_map<size_t, size_t>, std::vector<size_t>> bats::reduce_block_sequential(ColumnMatrix<TVec> &M, const size_t j0, const size_t j1)¶ reduce a block of columns sequentially
- Parameters
M – matrix to be reduced
j0 – start of column range
j1 – upper bound of column range
- Returns
p2c map from pivots to columns for this block
- Returns
nzcol vector of nonzero columns after reduction
Template Function bats::reduce_column_extra¶
Defined in File parallel.hpp
-
template<typename TVec>
void bats::reduce_column_extra(ColumnMatrix<TVec> &M, const size_t j, std::unordered_map<size_t, size_t> &p2c, typename TVec::tmp_type &tmp)¶ reduce a single column of the matrix M continue eliminating entries after finding pivot
assumes that p2c only contains columns < j
- Parameters
M – matrix
j – column to reduce
p2c – map from pivots to columns
tmp – preallocated for faster axpys
Template Function bats::reduce_column_sparsify¶
Defined in File reduction.hpp
-
template<typename TVec, typename F>
void bats::reduce_column_sparsify(ColumnMatrix<TVec> &M, const size_t j, std::vector<size_t> &pivot_to_col, std::map<F, size_t> &coeff, typename TVec::tmp_type &tmp)¶ greedily introduce sparsity into column j of M using columns k < j has the effect of reducing column j if not already reduced.
- Parameters
M – matrix
j – column to reduce
pivot_to_col – maps pivots to columns
coeff – preallocated map to use when sparsifying.
tmp – preallocated to use with axpy
Template Function bats::reduce_column_standard(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, const size_t, std::unordered_map<size_t, size_t>&, typename TVec::tmp_type&)¶
Defined in File parallel.hpp
-
template<typename TVec>
void bats::reduce_column_standard(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, const size_t j, std::unordered_map<size_t, size_t> &p2c, typename TVec::tmp_type &tmp)¶ reduce a single column of the matrix M
assumes that p2c only contains columns < j
- Parameters
M – matrix
U – change of basis matrix
j – column to reduce
p2c – map from pivots to columns
tmp – preallocated for faster axpys
Template Function bats::reduce_column_standard(ColumnMatrix<TVec>&, const size_t, std::unordered_map<size_t, size_t>&, typename TVec::tmp_type&)¶
Defined in File parallel.hpp
-
template<typename TVec>
void bats::reduce_column_standard(ColumnMatrix<TVec> &M, const size_t j, std::unordered_map<size_t, size_t> &p2c, typename TVec::tmp_type &tmp)¶ reduce a single column of the matrix M
assumes that p2c only contains columns < j
- Parameters
M – matrix
j – column to reduce
p2c – map from pivots to columns
tmp – preallocated for faster axpys
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, divide_conquer_flag)¶
Defined in File parallel.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, divide_conquer_flag)¶
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, divide_conquer_flag)¶
Defined in File parallel.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M, divide_conquer_flag)¶
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&)¶
Defined in File reduction.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M)¶
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, bats::standard_reduction_flag)¶
Defined in File reduction.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M, bats::standard_reduction_flag)¶
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, bats::extra_reduction_flag)¶
Defined in File reduction.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M, bats::extra_reduction_flag)¶
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)¶
Defined in File reduction.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U)¶
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, bats::standard_reduction_flag)¶
Defined in File reduction.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, bats::standard_reduction_flag)¶
Template Function bats::reduce_matrix(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, bats::extra_reduction_flag)¶
Defined in File reduction.hpp
-
template<class TVec>
inline std::vector<size_t> bats::reduce_matrix(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, bats::extra_reduction_flag)¶
Template Function bats::reduce_matrix_clearing¶
Defined in File reduction.hpp
-
template<class TVec, typename flag>
std::vector<size_t> bats::reduce_matrix_clearing(ColumnMatrix<TVec> &M, const std::vector<size_t> &clear_inds, flag)¶
Template Function bats::reduce_matrix_compression(ColumnMatrix<TVec>&, const std::vector<bool>&, flag)¶
Defined in File reduction.hpp
-
template<class TVec, typename flag>
std::vector<size_t> bats::reduce_matrix_compression(ColumnMatrix<TVec> &M, const std::vector<bool> &comp_inds, flag)¶
Template Function bats::reduce_matrix_compression(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, const std::vector<bool>&, flag)¶
Defined in File reduction.hpp
-
template<class TVec, typename flag>
std::vector<size_t> bats::reduce_matrix_compression(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U, const std::vector<bool> &comp_inds, flag)¶
Template Function bats::reduce_matrix_extra(ColumnMatrix<TVec>&)¶
Defined in File reduction.hpp
-
template<class TVec>
std::vector<size_t> bats::reduce_matrix_extra(ColumnMatrix<TVec> &M)¶
Template Function bats::reduce_matrix_extra(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)¶
Defined in File reduction.hpp
-
template<class TVec>
std::vector<size_t> bats::reduce_matrix_extra(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U)¶
Template Function bats::reduce_matrix_standard(ColumnMatrix<TVec>&)¶
Defined in File reduction.hpp
-
template<class TVec>
std::vector<size_t> bats::reduce_matrix_standard(ColumnMatrix<TVec> &M)¶
Template Function bats::reduce_matrix_standard(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)¶
Defined in File reduction.hpp
-
template<class TVec>
std::vector<size_t> bats::reduce_matrix_standard(ColumnMatrix<TVec> &M, ColumnMatrix<TVec> &U)¶
Template Function bats::remove_extra_cycles¶
Defined in File reduction.hpp
-
template<class TVec>
void bats::remove_extra_cycles(const ColumnMatrix<TVec> &R, ColumnMatrix<TVec> &U)¶ Update change of basis matrix to not be as dense by removing lower grade cycles from U.
Let j1 < j2, and R[j1] = 0 Then, we can add a linear combination of U[j1] to U[j2] without changing the matrix invatiant B*U = R
- Parameters
R – reduced matrix
U – change of basis matrix
Template Function bats::Rips(const Diagram<std::set<size_t>, std::vector<size_t>>&, const DataSet<T>&, const M&, const T, const size_t)¶
Defined in File functors.hpp
-
template<typename T, typename M>
Diagram<SimplicialComplex, CellularMap> bats::Rips(const Diagram<std::set<size_t>, std::vector<size_t>> &D, const DataSet<T> &X, const M &dist, const T rmax, const size_t dmax)¶
Template Function bats::Rips(const Diagram<std::set<size_t>, std::vector<size_t>>&, const DataSet<T>&, const M&, const std::vector<T>&, const size_t)¶
Defined in File functors.hpp
-
template<typename T, typename M>
Diagram<SimplicialComplex, CellularMap> bats::Rips(const Diagram<std::set<size_t>, std::vector<size_t>> &D, const DataSet<T> &X, const M &dist, const std::vector<T> &rmax, const size_t dmax)¶
Template Function bats::rips_filtration_edges(const DataSet<T>&, const M&, const T)¶
Defined in File rips.hpp
Template Function bats::rips_filtration_edges(const Matrix<T>&, const T)¶
Defined in File rips.hpp
Template Function bats::rips_filtration_edges(const DataSet<T>&, const bats::Cover&, const M&, const T)¶
Defined in File rips_cover.hpp
Template Function bats::RipsFiltration(const Matrix<T>&, T, size_t)¶
Defined in File rips.hpp
Template Function bats::RipsFiltration(const DataSet<T>&, const bats::Cover&, const M&, T, size_t)¶
Defined in File rips_cover.hpp
-
template<typename T, typename M>
Filtration<T, SimplicialComplex> bats::RipsFiltration(const DataSet<T> &X, const bats::Cover &cover, const M &dist, T rmax, size_t dmax)¶
Function bats::serpinski_diagram¶
Defined in File extras.hpp
-
Diagram<CellComplex, CellularMap> bats::serpinski_diagram(size_t k)¶
Template Function bats::SimplicialMap(const CpxT&, const CpxT&)¶
Defined in File simplicial_map.hpp
-
template<typename CpxT>
inline CellularMap bats::SimplicialMap(const CpxT &X, const CpxT &Y)¶
Template Function bats::SimplicialMap(const CpxT&, const CpxT&, const std::vector<size_t>&)¶
Defined in File simplicial_map.hpp
-
template<typename CpxT>
CellularMap bats::SimplicialMap(const CpxT &X, const CpxT &Y, const std::vector<size_t> &f0)¶
Template Function bats::sort_edges¶
Defined in File rips.hpp
Template Function bats::sort_indexes¶
Defined in File permutation.hpp
Template Function bats::sparsify_basis(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&, const size_t, std::map<F, size_t>&, typename TVec::tmp_type&)¶
Defined in File reduction.hpp
-
template<typename TVec, typename F>
void bats::sparsify_basis(ColumnMatrix<TVec> &R, ColumnMatrix<TVec> &U, const size_t j, std::map<F, size_t> &coeff, typename TVec::tmp_type &tmp)¶ greedily introduce sparsity into columns j of U and R using columns k < j assumes columns k <= j are already reduced
objective to greedily minimize is nnz(U[j]) + nnz(R[j])
- Parameters
R – reduced matrix
U – change of basis matrix
j – column
coeff – preallocated map to use when sparsifying.
tmp – preallocated to use with axpy
Template Function bats::sparsify_basis(ColumnMatrix<TVec>&, ColumnMatrix<TVec>&)¶
Defined in File reduction.hpp
-
template<typename TVec>
void bats::sparsify_basis(ColumnMatrix<TVec> &R, ColumnMatrix<TVec> &U)¶ greedily introduce sparsity into columns of U and R assumes R is already reduced
objective to greedily minimize is nnz(U[j]) + nnz(R[j])
- Parameters
R – reduced matrix
U – change of basis matrix
Template Function bats::type_A_dq_common¶
Defined in File sparse.hpp
Template Function bats::type_A_dq_EL¶
Defined in File sparse.hpp
Template Function bats::type_A_dq_EU¶
Defined in File sparse.hpp
Template Function bats::type_A_leftright_sweep1¶
Defined in File sparse.hpp
Template Function bats::type_A_leftright_sweep2¶
Defined in File sparse.hpp
Template Function bats::type_A_rightleft_sweep1¶
Defined in File sparse.hpp
Template Function bats::type_A_rightleft_sweep2¶
Defined in File sparse.hpp
Template Function bats::util::apply_iperm_swap¶
Defined in File permutation.hpp
Template Function bats::util::apply_perm(T *, const std::vector<size_t>&)¶
Defined in File permutation.hpp
Template Function bats::util::apply_perm(std::vector<T>&, const std::vector<size_t>&)¶
Defined in File permutation.hpp
Template Function bats::util::apply_perm_swap¶
Defined in File permutation.hpp
Function bats::util::fill_partial_sortperm¶
Defined in File permutation.hpp
Template Function bats::util::fill_sortperm(const std::vector<T>&, std::vector<size_t>&)¶
Defined in File permutation.hpp
Function bats::util::inv_perm¶
Defined in File permutation.hpp
Function bats::util::io::parse_argv(const int, char **, const std::string&&, const std::string)¶
Defined in File io.hpp
Template Function bats::util::is_degenerate¶
Defined in File simplex.hpp
Function bats::util::partial_perm¶
Defined in File permutation.hpp
Template Function bats::util::perm_inversions¶
Defined in File permutation.hpp
Template Function bats::util::perm_sign¶
Defined in File permutation.hpp
Function bats::util::rand_perm¶
Defined in File permutation.hpp
Function bats::util::random_subset¶
Defined in File set.hpp
Template Function bats::util::read_simplex¶
Defined in File simplex.hpp
Template Function bats::util::simplex_sign¶
Defined in File simplex.hpp
Function bats::util::sort_ind_by_perm¶
Defined in File permutation.hpp
Function bats::util::sort_ind_pair_by_perm¶
Defined in File permutation.hpp
Template Function bats::util::sort_sum_reduce¶
Defined in File sorted.hpp
Template Function bats::util::sortperm(const std::vector<T>&)¶
Defined in File permutation.hpp
Template Function bats::util::sortperm(RAI, RAI, Compare)¶
Defined in File permutation.hpp
-
template<typename RAI, class Compare>
std::vector<size_t> bats::util::sortperm(RAI first, RAI last, Compare comp)¶ filll a sortperm using custom comparator
- Parameters
first – random acces iterator at beginning of range to sort
last – random access iterator just past the last element of range to sort
comp – comparison function, comp(a, b) should return whether a should come before b
Template Function bats::util::sortperm(const size_t, const size_t, Compare)¶
Defined in File permutation.hpp
-
template<class Compare>
std::vector<size_t> bats::util::sortperm(const size_t first, const size_t last, Compare comp)¶ filll a sortperm using custom comparator
- Parameters
first – random acces iterator at beginning of range to sort
last – random access iterator just past the last element of range to sort
comp – comparison function, comp(a, b) should return whether a should come before b
Template Function bats::util::stable_sortperm¶
Defined in File permutation.hpp
Template Function bats::util::top_k¶
Defined in File permutation.hpp
Template Function bats::util::top_p¶
Defined in File permutation.hpp
Template Function bats::WitnessComplex(const DataSet<T>&, const DataSet<T>&, const M&, const size_t)¶
Defined in File dowker.hpp
Template Function bats::WitnessComplex(const DataSet<T>&, const DataSet<T>&, const M&, const size_t, const T, const size_t)¶
Defined in File dowker.hpp
Template Function bats::WitnessFiltration¶
Defined in File dowker.hpp
Template Function bats::zigzag::barcode¶
Defined in File zigzag_filtration.hpp
-
template<typename CpxT, typename T, typename FT, typename opt_flag, typename reduction_flag>
auto bats::zigzag::barcode(const ZigzagFiltration<CpxT, T> &F, ssize_t maxdim, FT, opt_flag, reduction_flag)¶
Template Function bats::zigzag::detail::boundary_insertion_map¶
Defined in File reduction.hpp
-
template<typename VecT>
ColumnMatrix<VecT> bats::zigzag::detail::boundary_insertion_map(const std::vector<size_t> &I, const size_t i, const VecT &v)¶
Template Function bats::zigzag::detail::cube_extrema¶
Defined in File extension.hpp
-
template<typename T>
std::pair<T, T> bats::zigzag::detail::cube_extrema(const std::vector<T> &f0, const std::vector<size_t> &cube, const size_t n)¶ get maximum and minimum value of a function on cube vertices
- Parameters
f0 – function on vertices - in column-major order
cube – representation of cube, can be degenerate
n – length of 3D cube
Template Function bats::zigzag::detail::cycle_insertion_map¶
Defined in File reduction.hpp
-
template<typename VecT>
ColumnMatrix<VecT> bats::zigzag::detail::cycle_insertion_map(const std::vector<size_t> &I, const size_t j)¶
Function bats::zigzag::detail::lex_cmp¶
Defined in File zigzag_filtration.hpp
-
bool bats::zigzag::detail::lex_cmp(const bats::SimplicialComplex &X, size_t dimi, size_t i, size_t dimj, size_t j)¶
Compare simplices in lexicographical order looking at largest vertex first (v_0,…,v_p) < (w_0,…,w_q) if v_p < w_q
compare simplex i in dimension dimi with simplex j in dimension dimj
- Parameters
X – simplicial complex
dimi – dimension of first simplex
i – index of first simplex
dimj – dimension of second simplex
j – index of second simplex
- Returns
true if first simplex < second simplex, false otherwise
Function bats::zigzag::detail::rlex_cmp¶
Defined in File zigzag_filtration.hpp
-
bool bats::zigzag::detail::rlex_cmp(const bats::SimplicialComplex &X, size_t dimi, size_t i, size_t dimj, size_t j)¶
Template Function bats::zigzag::detail::update_bars¶
Defined in File reduction.hpp
Template Function bats::zigzag::extend_levelset¶
Defined in File extension.hpp
-
template<typename T>
std::vector<std::vector<std::pair<T, T>>> bats::zigzag::extend_levelset(const std::vector<T> &f0, const CubicalComplex &X, const T eps, const size_t n)¶ Extension of zigzag filtration on vertices to a zigzag filtration on a cubical complex. The filtration progresses from low to high values.
- Parameters
f0 – function on vertices - stored in column-major format
X – CubicalComplex - on a vertex set of size n^3
eps – thickened levelset radius
n – length of cube
- Returns
val vector of vector of pairs holding zigzag filtration values for each cube.
Template Function bats::zigzag::extend_zigzag_filtration(const std::vector<T>&, const CpxT&, const T)¶
Defined in File extension.hpp
-
template<typename T, typename CpxT>
auto bats::zigzag::extend_zigzag_filtration(const std::vector<T> &f0, const CpxT &X, const T eps)¶ Extension of right filtration on 0-cells to right-filtration on all cells in a complex. Right filtration goes from low to high values
A 0-cell x enters the filtration at parameter f0(x) - eps and is removed from the filtration at parameter f0(x) + eps
Higher-dimensional cells are present for the interval that all faces are also present.
- Parameters
f0 – function on 0-cells
X – complex representing topological space
eps – thickened levelset radius
Template Function bats::zigzag::extend_zigzag_filtration(const std::vector<T>&, const CubicalComplex&, const T, const size_t)¶
Defined in File extension.hpp
-
template<typename T>
ZigzagFiltration<CubicalComplex, T> bats::zigzag::extend_zigzag_filtration(const std::vector<T> &f0, const CubicalComplex &X, const T eps, const size_t n)¶
Template Function bats::zigzag::extra_col_reduction¶
Defined in File reduction.hpp
-
template<class VecT>
void bats::zigzag::extra_col_reduction(const size_t j, ColumnMatrix<VecT> &M, ColumnMatrix<VecT> &U, const std::vector<size_t> &p2c, typename VecT::tmp_type &tmp)¶ reduce column j past the pivot. Heuristic strategy to reduce fill-in during reduction
Template Function bats::zigzag::prepare_ChainComplex(const ZigzagFiltration<CpxT, T>&, FT)¶
Defined in File zigzag_filtration.hpp
Template Function bats::zigzag::prepare_ChainComplex(const ZigzagFiltration<bats::SimplicialComplex, T>&, FT)¶
Defined in File zigzag_filtration.hpp
-
template<typename T, typename FT>
auto bats::zigzag::prepare_ChainComplex(const ZigzagFiltration<bats::SimplicialComplex, T> &F, FT)¶
Template Function bats::zigzag::reduce_column(size_t, ColumnMatrix<VecT>&, ColumnMatrix<VecT>&, std::vector<size_t>&, typename VecT::tmp_type&, reduction_flag)¶
Defined in File reduction.hpp
-
template<typename VecT, typename reduction_flag>
size_t bats::zigzag::reduce_column(size_t j, ColumnMatrix<VecT> &M, ColumnMatrix<VecT> &U, std::vector<size_t> &p2c, typename VecT::tmp_type &tmp, reduction_flag)¶ reduce column j past the pivot. Heuristic strategy to reduce fill-in during reduction reduce a column of M. Will eliminate pivots in column using columns to the left. If a pivot is shared by column to right, we will continue reduction on the column to the right.
- Parameters
j – column to reduce
M – partially reduced matrix
U – basis matrix
p2c – maps pivots to columns for reduction
- Returns
final column which was updated
Template Function bats::zigzag::reduce_column(size_t, ColumnMatrix<VecT>&, ColumnMatrix<VecT>&, std::vector<size_t>&, typename VecT::tmp_type&, bats::extra_reduction_flag)¶
Defined in File reduction.hpp
-
template<typename VecT>
size_t bats::zigzag::reduce_column(size_t j, ColumnMatrix<VecT> &M, ColumnMatrix<VecT> &U, std::vector<size_t> &p2c, typename VecT::tmp_type &tmp, bats::extra_reduction_flag)¶
Template Function bats::zigzag::zigzag_barcode_reduction¶
Defined in File reduction.hpp
-
template<typename MT, typename T, typename opt_flag, typename reduction_flag>
auto bats::zigzag::zigzag_barcode_reduction(const ChainComplex<MT> &C, const std::vector<rfilt_val<T>> &filt_order, ssize_t maxdim, opt_flag, reduction_flag)¶ computes zigzag barcode
Computes a zigzag barcode given a chain complex, entry times, and exit times
Computes reduced matrices directly, and assumes that they have already been permuted into the correct order.
TODO: don’t compute top dimension homology - assume spurious TODO: strategy for keeping homology dimensions small when adding a bunch of cells at the same time.
- Parameters
C – Chain complex (in zigzag reduction order)
filt_order – order in which zigzag filtration occurs
maxdim – maximum homology dimension to compute. If set to -1, will default to computing all but top dimension.
Template Function bats::zigzag_levelsets¶
Defined in File levelset.hpp
-
template<typename CpxT, typename T>
auto bats::zigzag_levelsets(const zigzag::ZigzagFiltration<CpxT, T> &X, T eps, T t0, T t1)¶ Function which creates a blocked levelset zigzag diagram from a zigzag::ZigzagFiltration
f^{-1}([s_i,s_{i+1}]) f^{-1}([s_i, s_{i+2}]) f^{-1}([s_{i+1}, s_{i+2}])
where eps = s_{i+1} - s_i
- Parameters
eps – window size
t0 – lower bound on first window
t1 – upper bound on last window
Template Function bats::zigzag_toplex¶
Defined in File levelset.hpp
-
template<typename T>
zigzag::ZigzagFiltration<CubicalComplex, T> bats::zigzag_toplex(const std::vector<std::vector<std::vector<T>>> &img)¶ Create a zigzag filtration from a 3D image.
Extend zigzag filtration from toplexes i.e. the maximal cubes correspond to the pixel grid.
Lower-dimensional cube filtration values are extended from cofaces
This means a n1 x n2 x n3 image will be on a vertex set of size (n1 + 1) x (n2 + 1) x (n3 + 1)
Template Function characteristic_matrix¶
Defined in File polynomial.hpp
-
template<typename T>
auto characteristic_matrix(const ColumnMatrix<SparseVector<T>> &A)¶
Template Function complete_pairs¶
Defined in File filtration.hpp
Template Function CU_inplace¶
Defined in File sparse_fact.hpp
-
template<class TC>
void CU_inplace(ColumnMatrix<TC> &C, ColumnMatrix<TC> &U)¶
Template Function delete_pivot¶
Defined in File sparse_fact.hpp
-
template<class TC>
inline void delete_pivot(const ColumnMatrix<TC> &A, std::map<size_t, std::vector<size_t>> &p2c, size_t j, size_t i0)¶
Template Function EL_L_commute¶
Defined in File sparse_fact.hpp
-
template<typename TC>
ColumnMatrix<TC> EL_L_commute(const ColumnMatrix<TC> &E, const ColumnMatrix<TC> &L)¶
Template Function EU_U_commute¶
Defined in File sparse_fact.hpp
-
template<typename TC>
inline ColumnMatrix<TC> EU_U_commute(const ColumnMatrix<TC> &EU, const ColumnMatrix<TC> &U)¶
Function extract_pairs¶
Defined in File extract.hpp
-
std::vector<size_t> extract_pairs(ColumnMatrix<TVec> &M, std::map<size_t, size_t> pivot_to_col)¶
Template Function extract_row_scale¶
Defined in File sparse_fact.hpp
-
template<typename TC>
auto extract_row_scale(ColumnMatrix<TC> &E)¶
Template Function gemv¶
Defined in File col_matrix.hpp
Template Function generating_basis¶
Defined in File rcf.hpp
-
template<typename T>
ColumnMatrix<SparseVector<T>> generating_basis(const ColumnMatrix<SparseVector<UnivariatePolynomial<T>>> &R, const ColumnMatrix<SparseVector<T>> &A)¶
Template Function get_pivots¶
Defined in File sparse_fact.hpp
-
template<class TC>
std::map<size_t, std::vector<size_t>> get_pivots(const ColumnMatrix<TC> &A)¶
Template Function inv¶
Defined in File sparse_fact.hpp
-
template<class TC>
ColumnMatrix<TC> inv(const ColumnMatrix<TC> &A)¶
Function isprime¶
Defined in File field.hpp
Template Function L_EL_commute¶
Defined in File sparse_fact.hpp
-
template<typename TC>
inline ColumnMatrix<TC> L_EL_commute(const ColumnMatrix<TC> &L, const ColumnMatrix<TC> &EL)¶
Template Function l_inv¶
Defined in File col_matrix.hpp
-
template<class TC>
ColumnMatrix<TC> l_inv(const ColumnMatrix<TC> &L)¶
Template Function l_solve(const ColumnMatrix<TC>&, const TC&)¶
Defined in File col_matrix.hpp
Template Function l_solve(const ColumnMatrix<TC>&, const ColumnMatrix<TC>&)¶
Defined in File col_matrix.hpp
-
template<class TC>
ColumnMatrix<TC> l_solve(const ColumnMatrix<TC> &L, const ColumnMatrix<TC> &A)¶
Template Function LEUP¶
Defined in File sparse_fact.hpp
-
template<class TC>
SparseFact<TC> LEUP(const ColumnMatrix<TC> &A)¶
Template Function LEUP_inplace¶
Defined in File sparse_fact.hpp
-
template<class TC>
void LEUP_inplace(SparseFact<TC> &F)¶
Template Function lower_star_filtration(const bats::CubicalComplex&, const std::vector<std::vector<T>>&)¶
Defined in File extension.hpp
-
template<typename T>
auto lower_star_filtration(const bats::CubicalComplex &X, const std::vector<std::vector<T>> &f0)¶
Template Function lower_star_filtration(const bats::CubicalComplex&, const std::vector<std::vector<std::vector<T>>>&)¶
Defined in File extension.hpp
-
template<typename T>
auto lower_star_filtration(const bats::CubicalComplex &X, const std::vector<std::vector<std::vector<T>>> &f0)¶
Template Function LQU¶
Defined in File sparse_fact.hpp
-
template<class TC>
SparseFact<TC> LQU(const ColumnMatrix<TC> &A)¶
Template Function LQU_inplace¶
Defined in File sparse_fact.hpp
-
template<class TC>
void LQU_inplace(SparseFact<TC> &F)¶
Template Function max_cube_val(const std::vector<size_t>&, const std::vector<std::vector<T>>&)¶
Defined in File extension.hpp
Template Function max_cube_val(const std::vector<size_t>&, const std::vector<std::vector<std::vector<T>>>&)¶
Defined in File extension.hpp
Template Function pivot_ind¶
Defined in File sparse_fact.hpp
-
template<typename TC>
inline size_t pivot_ind(const ColumnMatrix<TC> &E, size_t j)¶
Template Function PLEU¶
Defined in File sparse_fact.hpp
-
template<class TC>
SparseFact<TC> PLEU(const ColumnMatrix<TC> &A)¶
Template Function PLEU_inplace¶
Defined in File sparse_fact.hpp
-
template<class TC>
void PLEU_inplace(SparseFact<TC> &F)¶
Template Function PUEL¶
Defined in File sparse_fact.hpp
-
template<class TC>
SparseFact<TC> PUEL(const ColumnMatrix<TC> &A)¶
Template Function PUEL_inplace¶
Defined in File sparse_fact.hpp
-
template<class TC>
void PUEL_inplace(SparseFact<TC> &F)¶
Template Function RCF_basis¶
Defined in File rcf.hpp
-
template<typename T>
ColumnMatrix<SparseVector<T>> RCF_basis(const ColumnMatrix<SparseVector<UnivariatePolynomial<T>>> &S, const ColumnMatrix<SparseVector<T>> &A, const ColumnMatrix<SparseVector<T>> &B)¶
Template Function schur(ColumnMatrix<CT>&, ColumnMatrix<CT>&, ColumnMatrix<CT>&, ColumnMatrix<CT>&)¶
Defined in File schur.hpp
-
template<typename CT>
ColumnMatrix<CT> schur(ColumnMatrix<CT> &A, ColumnMatrix<CT> &B, ColumnMatrix<CT> &C, ColumnMatrix<CT> &D)¶
Template Function schur(const ColumnMatrix<TV>&, const size_t, const size_t, const size_t, const size_t)¶
Defined in File schur.hpp
-
template<typename TV>
auto schur(const ColumnMatrix<TV> &A, const size_t i0, const size_t i1, const size_t j0, const size_t j1)¶
Template Function smith_factorization¶
Defined in File pid.hpp
Template Function smith_normal_form¶
Defined in File pid.hpp
-
template<typename TC>
void smith_normal_form(ColumnMatrix<TC> &A)¶
Template Function smith_rows¶
Defined in File pid.hpp
-
template<class TC>
std::tuple<ColumnMatrix<TC>, ColumnMatrix<TC>> smith_rows(const ColumnMatrix<TC> &A)¶
Template Function U_EU_commute¶
Defined in File sparse_fact.hpp
-
template<typename TC>
inline ColumnMatrix<TC> U_EU_commute(const ColumnMatrix<TC> &U, const ColumnMatrix<TC> &EU)¶
Template Function u_inv¶
Defined in File col_matrix.hpp
-
template<class TC>
ColumnMatrix<TC> u_inv(const ColumnMatrix<TC> &U)¶
Template Function u_solve(const ColumnMatrix<TC>&, const TC&)¶
Defined in File col_matrix.hpp
Template Function u_solve(const ColumnMatrix<TC>&, const ColumnMatrix<TC>&)¶
Defined in File col_matrix.hpp
-
template<class TC>
ColumnMatrix<TC> u_solve(const ColumnMatrix<TC> &U, const ColumnMatrix<TC> &A)¶
Template Function UELP¶
Defined in File sparse_fact.hpp
-
template<class TC>
SparseFact<TC> UELP(const ColumnMatrix<TC> &A)¶
Template Function UELP_inplace¶
Defined in File sparse_fact.hpp
-
template<class TC>
void UELP_inplace(SparseFact<TC> &F)¶
Template Function update_pivot¶
Defined in File sparse_fact.hpp
-
template<class TC>
inline void update_pivot(const ColumnMatrix<TC> &A, std::map<size_t, std::vector<size_t>> &p2c, size_t j, size_t i0)¶
Template Function UQL¶
Defined in File sparse_fact.hpp
-
template<class TC>
SparseFact<TC> UQL(const ColumnMatrix<TC> &A)¶
Variables¶
Variable bats::NO_IND¶
Defined in File common.hpp
Defines¶
Define APPLY_INVERSE_ON_LEFT¶
Defined in File symbolic_implementation.hpp
Define APPLY_INVERSE_ON_RIGHT¶
Defined in File symbolic_implementation.hpp
Define IMPL_FACT¶
Defined in File symbolic_implementation.hpp
About BATS¶
BATS is a library for applied algebraic topology.