The following methods must be implemented:

• boundaryOperator

This matrix type assumes that the number of entries in each row never increases.

Because of this, we have

• getindex for a row in log(nnz)
• getindex for a column in #(nnz in column)

function allBoundaryMatrices(C::CellComplex)

First, computes all boundary matrices. Then, returns them.

function apply!(A::Array{T,2}, addOp::ColAddOperation{T}) where T <: Integer

Applies a ColAddOperation.

function apply!(A::AbstractArray{T,2}, crOp::CoreductionOperation{T}) where T <: Integer

Applies the coreduction operation. See restore for details.

function basicReductions!(D1::AbstractSparseMatrix{T,Int}; kernelOperations::Stack{KernelOperation}) where T <: Integer

Performs basic coreductions, i.e. reductions of rows with up to two entries.

function basicReductions!(D1::AbstractSparseMatrix{T,Int}, kernelOperations::Stack{KernelOperation}=Stack{KernelOperation}, colRemoved::Vector{Bool}=zeros(Bool,size(D1,2))) where T <: Integer

Performs basic reductions, i.e. reductions of columns with up to two entries.

function boundaryMatrix(C::CellComplex, i)

Returns the i-th boundary matrix of the complex C

function boundaryMatrix(C1, C2)

Given a pair of cubical chain groups with bdy(C2) ⊂ C1 this computes the boundary matrix

function circularCoordinates(h, A)

Computes a matrix A such that A[i,:] contains the values of a circle valued function corresponding to the i-th generator of h on the basis of C^0 of h which was used to compute h.D0.

function coboundaryMatrix(C::CellComplex, i)

Returns the i-th coboundary matrix of the complex C

function d1Kernel!(A::Array{2,T},kerOp::Stack{KernelOperation}=Stack{KernelOperation}(),colRemoved::Vector{Bool}=zeros(Bool,size(D0,1))) where {T <: Integer}

Computes the kernel using row reduction.

function d1Kernel!(D1::AbstractSparseMatrix{T,Int},kerOp::Stack{KernelOperation},preprocess=colRemoved) where {T <: Integer}

Computes the kernel of a 1st boundary matrix.

function findMaxSpanningTree(D0,D1; colRemoved::Vector{Bool}=zeros(Bool,size(D0,1)))

Finds a maximal spanning tree in D0. Edge weight is number of entries in the corresponding column in D1.

function getUnitVectors(indices, m, T=Int)

Returns a sparse (m,lenth(indices))-matrix of type T with i-th column being indices[i]-th standard basis vector.

function liftOfCircleValuedFunction(h::H1, A, LSQR_ATOL = LSQR_TOL, LSQR_RTOL = LSQR_TOL)

Computes a matrix A such that A[i,:] contains the values of a lift of the circle valued function corresponding to the i-th generator of h on the basis of C^0 of h which was used to compute h.D0. This is useful for example to compute the norm of a generator.

function norms(h::H1)

computes the l2 norms of the generators

function oneSkeleton(D::AbstractArray{T,2}, r) where T <: Number

Returns the 1-skeleton of the VR-complex with distance matrix D. D only need the lower left entries.

function redCored!(D1::AbstractSparseMatrix{T,Int}, ) where {T <: Integer}

function removeMaxSpanningTree!(D0::AbstractSparseMatrix{T0,Int},D1::AbstractSparseMatrix{T1,Int}; colRemoved::Vector{Bool}=zeros(Bool,size(D0,1))) where {T0 <: Integer, T1 <: Integer}

Finds a maximal spanning tree in the graph defined by D0 with the edges in colRemoved ignored. It then removes the spanning tree by setting the corresponding columns in D1 to zero.

function restore!(A::Array{T,2}, addOp::ColAddOperation{T}) where T <: Integer

Restores a ColAddOperation. Therefore, it is the row(!) operation modeled by the same matrix.

function restore!(A::Array{T,2}, addOp::ColAddOperation{T}) where T <: Integer

Restores a coreduction two-reduction. Start is i j [****|*****|**** ****|*****|**** –- x –- y –- ****|*****|**** ****|*****|****]

The reduction had to be performed with discardColValuekeepCol - keepColValueDiscardCol

function restore!(A::Array{T,2}, basicReduction::ReductionOperation{T}) where T <: Integer

Restores the kernel after a basic reduction operation (where a row gets removed).

function vrIncremental(X::AbstractArray{T,2}, d, r; maxdim=size(X,1)) where T <: Number

Compute VR complex for a given point cloud X, distance function d and radius r.

function vrIncremental(D::AbstractArray{T,2}, r; maxdim=size(D,1)) where T <: Number

Constructs the VR-complex from a distance matrix using the incremental construction.