edu.stanford.math.plex

Class PersistenceBasis

java.lang.Object

edu.stanford.math.plex.PersistenceBasis

public class PersistenceBasis
extends java.lang.Object

The class PersistenceBasis implements the Persistence algorithm by Carlsson-Zomorodian, with additional basis element tracking to make sure that afterwards, basis elements for the persistence intervals may be extracted.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	PersistenceBasis.ListItem
protected static class	PersistenceBasis.SimplexType

Field Summary

Fields

Modifier and Type	Field and Description
protected static int	p
protected static int[]	pInverses

Constructor Summary

Constructors

Constructor and Description
PersistenceBasis()

Method Summary

Methods

Modifier and Type	Method and Description
static int	baseModulus() What is modulus of the coefficient field?
static int[][]	basis(SimplexStream stream, int degree, double findex)
static double[][]	boundaryMatrix(SimplexStream stream, double findex, int degree) Returns a boundary matrix for a given simple simplex stream in a format usable from Matlab.
static double[][]	boundaryMatrixSparse(SimplexStream stream, double findex, int degree) Returns a sparse boundary matrix for a given simple simplex stream in a format usable from Matlab.
static double[]	chainVector(SimplexStream stream, Chain chain, double findex)
static PersistenceBasisInterval.Float[]	computeIntervals(SimplexStream sstream) Compute the persistent homology intervals of the simplex stream given.
static PersistenceBasisInterval.Float[]	computeIntervals(SimplexStream sstream, boolean retrofit) Compute the persistent homology intervals of the simplex stream given with an option flag to control which type of basis we want to choose.
PersistenceBasisInterval.Float[]	computeIntervals(SimplexStream sstream, int prime, boolean retrofit) Compute the persistent homology intervals of the simplex stream given with explicitly given characteristic of the underlying field as well as an option flag to control which type of basis we want to choose.
static PersistenceBasisInterval[]	computePersistentCohomologyZigZag(SimplexStream stream)
static PersistenceBasisInterval[]	computePersistentCohomologyZigZag(SimplexStream stream, int prime) Computes persistent cohomology using a zig-zag based approach due to Dmitriy Morozov.
PersistenceBasisInterval[]	computeRawIntervals(SimplexStream sstream, int prime)
protected static int[]	multiplicative_inverses(int p)
static void	setBaseModulus(int modulus) Set or reset the coefficient field.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

p

protected static int p

pInverses

protected static int[] pInverses

Constructor Detail

PersistenceBasis

public PersistenceBasis()

Method Detail

baseModulus

public static int baseModulus()

What is modulus of the coefficient field?

setBaseModulus

public static void setBaseModulus(int modulus)

Set or reset the coefficient field.

Parameters:

modulus - Must be a prime in [2,255].

Throws:

java.lang.IllegalArgumentException

multiplicative_inverses

protected static int[] multiplicative_inverses(int p)

boundaryMatrix

public static double[][] boundaryMatrix(SimplexStream stream,
                        double findex,
                        int degree)

Returns a boundary matrix for a given simple simplex stream in a format usable from Matlab.

Parameters:

stream - SimpleSimplexStream providing the simplices

findex - The filtration index at which to perform the computation

degree - We want the boundary matrix taking simplices of dimension degree to simplices of dimension degree-1

boundaryMatrixSparse

public static double[][] boundaryMatrixSparse(SimplexStream stream,
                              double findex,
                              int degree)

Returns a sparse boundary matrix for a given simple simplex stream in a format usable from Matlab. In the return format, a double[n][3] matrix is returned, with each row consisting of rowindex, columnindex and value, so that the three sections may be fed into Matlab's sparse command.

Parameters:

stream - SimpleSimplexStream providing the simplices

findex - The filtration index at which to perform the computation

degree - We want the boundary matrix taking simplices of dimension degree to simplices of dimension degree-1

chainVector

public static double[] chainVector(SimplexStream stream,
                   Chain chain,
                   double findex)

basis

public static int[][] basis(SimplexStream stream,
            int degree,
            double findex)

computeIntervals

public static PersistenceBasisInterval.Float[] computeIntervals(SimplexStream sstream)

Compute the persistent homology intervals of the simplex stream given. This function is a wrapper to make the call easy with good default behaviour.

Parameters:

sstream - The simplex stream representing the filtered complex of which the homology is computed.

Returns:

An array of type PersistenceBasisInterval carrying the relevant persistence intervals with basis elements.

computeIntervals

public static PersistenceBasisInterval.Float[] computeIntervals(SimplexStream sstream,
                                                boolean retrofit)

Compute the persistent homology intervals of the simplex stream given with an option flag to control which type of basis we want to choose.

Parameters:

sstream - The simplex stream representing the filtered complex of which the homology is computed.

retrofit - If false, the basis element is guaranteed to exist throughout the entire interval. If true, the basis element of a finite interval will correspond to the reduced boundary of the simplex killing the interval.

Returns:

An array of type PersistenceBasisInterval carrying the relevant persistence intervals with basis elements.

computeIntervals

public PersistenceBasisInterval.Float[] computeIntervals(SimplexStream sstream,
                                                int prime,
                                                boolean retrofit)

Compute the persistent homology intervals of the simplex stream given with explicitly given characteristic of the underlying field as well as an option flag to control which type of basis we want to choose.

Parameters:

sstream - The simplex stream representing the filtered complex of which the homology is computed.

prime - The characteristic of the base field of the computation.

retrofit - If false, the basis element is guaranteed to exist throughout the entire interval. If true, the basis element of a finite interval will correspond to the reduced boundary of the simplex killing the interval.

Returns:

An array of type PersistenceBasisInterval carrying the relevant persistence intervals with basis elements.

computeRawIntervals

public PersistenceBasisInterval[] computeRawIntervals(SimplexStream sstream,
                                             int prime)

computePersistentCohomologyZigZag

public static PersistenceBasisInterval[] computePersistentCohomologyZigZag(SimplexStream stream,
                                                           int prime)

Computes persistent cohomology using a zig-zag based approach due to Dmitriy Morozov.

Seems to compute wrongly. Need to step through small examples and work out what exactly what's happening. Diagnosis: too high dimensional cocycles occurring, and way too many of them. The cocycles expected do not occur.

Parameters:

stream - SimpleSimplexStream providing the simplices

Returns:

PersistenceBasisInterval[] carrying the computed intervals and their basis elements.

computePersistentCohomologyZigZag

public static PersistenceBasisInterval[] computePersistentCohomologyZigZag(SimplexStream stream)