edu.stanford.math.plex4.api

Class Plex4

java.lang.Object

edu.stanford.math.plex4.api.Plex4

public class Plex4
extends java.lang.Object

This class contains static functions that are designed to be callable from Matlab.

Author:

Andrew Tausz

Constructor Summary

Constructors

Constructor and Description
Plex4()

Method Summary

Methods

Modifier and Type	Method and Description
static <G> void	createBarcodePlot(PersistenceInvariantDescriptor<Interval<java.lang.Double>,G> collection, java.lang.String caption, double endPoint) This function creates an images of a collection of barcodes and writes it to a file.
static EuclideanMetricSpace	createEuclideanMetricSpace(double[][] points) This function creates a new EuclideanMetricSpace object.
static ExplicitCellStream	createExplicitCellStream() This function creates a new ExplicitCellStream object.
static ExplicitCellStream	createExplicitCellStream(double maxFiltrationValue)
static <T> ExplicitLandmarkSelector<T>	createExplicitSelector(AbstractSearchableMetricSpace<T> metricSpace, int[] landmarkPoints) This function creates a new explicit landmark selector on an abstract metric space.
static ExplicitLandmarkSelector<double[]>	createExplicitSelector(double[][] points, int[] landmarkPoints) This function creates a new explicit landmark selector on a point cloud.
static ExplicitSimplexStream	createExplicitSimplexStream() This function creates a new ExplicitSimplexStream object.
static ExplicitSimplexStream	createExplicitSimplexStream(double maxFiltrationValue)
static edu.stanford.math.primitivelib.autogen.formal_sum.DoubleMatrixConverter<Simplex,Simplex>	createHomMatrixConverter(AbstractFilteredStream<Simplex> domainStream, AbstractFilteredStream<Simplex> codomainStream) This function creates a matrix converter object for converting between formal sums, sparse and dense matrices.
static <T,U> HomStream<T,U>	createHomStream(AbstractFilteredStream<T> domainStream, AbstractFilteredStream<U> codomainStream) This function creates a new hom stream from two given filtered streams.
static LazyWitnessStream<double[]>	createLazyWitnessStream(LandmarkSelector<double[]> selector, int maxDimension, double maxFiltrationValue) This function create a new lazy-witness stream given a point cloud.
static LazyWitnessStream<double[]>	createLazyWitnessStream(LandmarkSelector<double[]> selector, int maxDimension, double maxFiltrationValue, int numDivisions) This function create a new lazy-witness stream given a point cloud.
static edu.stanford.math.primitivelib.autogen.formal_sum.DoubleVectorConverter<Simplex>	createMatrixConverter(AbstractFilteredStream<Simplex> stream) This function creates a vector converter for converting between formal sums, and sparse and dense arrays.
static <T> MaxMinLandmarkSelector<T>	createMaxMinSelector(AbstractSearchableMetricSpace<T> metricSpace, int numLandmarkPoints) This function creates a new max-min landmark selector on an abstract metric space.
static <T> MaxMinLandmarkSelector<T>	createMaxMinSelector(AbstractSearchableMetricSpace<T> metricSpace, int numLandmarkPoints, int firstPoint) This function creates a new max-min landmark selector on an abstract metric space.
static MaxMinLandmarkSelector<double[]>	createMaxMinSelector(double[][] points, int numLandmarkPoints) This function creates a new max-min landmark selector on a point cloud.
static MaxMinLandmarkSelector<double[]>	createMaxMinSelector(double[][] points, int numLandmarkPoints, int firstPoint) This function creates a new max-min landmark selector on a point cloud.
static <T> RandomLandmarkSelector<T>	createRandomSelector(AbstractSearchableMetricSpace<T> metricSpace, int numLandmarkPoints) This function creates a new randomized landmark selector on an abstract metric space.
static RandomLandmarkSelector<double[]>	createRandomSelector(double[][] points, int numLandmarkPoints) This function creates a new random landmark point selector on a point cloud.
static <T> VietorisRipsStream<T>	createVietorisRipsStream(AbstractSearchableMetricSpace<T> metricSpace, int maxDimension, double maxFiltrationValue) This function creates a Vietoris-Rips complex given a metric space.
static <T> VietorisRipsStream<T>	createVietorisRipsStream(AbstractSearchableMetricSpace<T> metricSpace, int maxDimension, double[] filtrationValues) This function creates a Vietoris-Rips complex from a metric space.
static <T> VietorisRipsStream<T>	createVietorisRipsStream(AbstractSearchableMetricSpace<T> metricSpace, int maxDimension, double maxFiltrationValue, int numDivisions) This function creates a Vietoris-Rips complex from a metric space.
static VietorisRipsStream<double[]>	createVietorisRipsStream(double[][] points, int maxDimension, double maxFiltrationValue) This function creates a Vietoris-Rips complex given a point cloud.
static VietorisRipsStream<double[]>	createVietorisRipsStream(double[][] points, int maxDimension, double[] filtrationValues) This function creates a Vietoris-Rips complex given a point cloud.
static VietorisRipsStream<double[]>	createVietorisRipsStream(double[][] points, int maxDimension, double maxFiltrationValue, int numDivisions) This function creates a Vietoris-Rips complex given a point cloud.
static WitnessStream<double[]>	createWitnessStream(LandmarkSelector<double[]> selector, int maxDimension, double maxFiltrationValue) This function create a new witness stream given a point cloud.
static WitnessStream<double[]>	createWitnessStream(LandmarkSelector<double[]> selector, int maxDimension, double maxFiltrationValue, int numDivisions) This function create a new witness stream given a point cloud.
static double	estimateDiameter(AbstractIntMetricSpace metricSpace) This function estimates the diameter of a metric space.
static AbstractPersistenceAlgorithm<Cell>	getDefaultCellularAlgorithm(int maxDimension) This function returns the default (absolute) cellular persistent homology algorithm.
static AbstractPersistenceAlgorithm<Simplex>	getDefaultSimplicialAlgorithm(int maxDimension) This function returns the default (absolute) simplicial persistent homology algorithm.
static AbstractPersistenceAlgorithm<SimplexPair>	getDefaultSimplicialPairAlgorithm(int maxDimension)
static AbstractPersistenceAlgorithm<Cell>	getModularCellularAlgorithm(int maxDimension, int prime) This function returns a cellular persistence algorithm over the finite field Z/pZ.
static AbstractPersistenceAlgorithm<Simplex>	getModularSimplicialAlgorithm(int maxDimension, int prime) This function returns a simplicial persistence algorithm over the finite field Z/pZ.
static AbstractPersistenceAlgorithm<Cell>	getRationalCellularAlgorithm(int maxDimension) This function returns a cellular persistence algorithm over the the rational numbers.
static ObjectPersistenceAlgorithm<org.apache.commons.math.fraction.Fraction,edu.stanford.math.primitivelib.autogen.pair.ObjectObjectPair<Simplex,Simplex>>	getRationalHomAlgorithm() This function creates a persistent homology algorithm over the rationals for computing homology of simplicial hom complexes.
static ObjectAbsoluteHomology<org.apache.commons.math.fraction.Fraction,Simplex>	getRationalSimplicialAlgorithm(int maxDimension) This function returns a simplicial persistence algorithm over the the rational numbers.
static void	main(java.lang.String[] args) Empty main function for convenience only.

Methods inherited from class java.lang.Object

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

Constructor Detail

Plex4

public Plex4()

Method Detail

main

public static void main(java.lang.String[] args)

Empty main function for convenience only.

Parameters:

args -

createEuclideanMetricSpace

public static EuclideanMetricSpace createEuclideanMetricSpace(double[][] points)

This function creates a new EuclideanMetricSpace object.

Parameters:

points - the array of points to include in the metric space

Returns:

a new EuclideanMetricSpace object containing the supplied points

estimateDiameter

public static double estimateDiameter(AbstractIntMetricSpace metricSpace)

This function estimates the diameter of a metric space. The diameter is defined as the maximum pairwise distance within the space.

Parameters:

metricSpace - the metric space

Returns:

the estimated diameter

createExplicitSimplexStream

public static ExplicitSimplexStream createExplicitSimplexStream()

This function creates a new ExplicitSimplexStream object.

Returns:

a new ExplicitSimplexStream

createExplicitSimplexStream

public static ExplicitSimplexStream createExplicitSimplexStream(double maxFiltrationValue)

createExplicitCellStream

public static ExplicitCellStream createExplicitCellStream()

This function creates a new ExplicitCellStream object.

Returns:

a new ExplicitCellStream

createExplicitCellStream

public static ExplicitCellStream createExplicitCellStream(double maxFiltrationValue)

createVietorisRipsStream

public static VietorisRipsStream<double[]> createVietorisRipsStream(double[][] points,
                                                    int maxDimension,
                                                    double maxFiltrationValue,
                                                    int numDivisions)

This function creates a Vietoris-Rips complex given a point cloud.

Parameters:

points - the points in the data set

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

numDivisions - the number of divisions to use in the filtration

Returns:

a new VietorisRipsStream object

createVietorisRipsStream

public static VietorisRipsStream<double[]> createVietorisRipsStream(double[][] points,
                                                    int maxDimension,
                                                    double maxFiltrationValue)

This function creates a Vietoris-Rips complex given a point cloud. It uses 20 as the default number of divisions.

Parameters:

points - the points in the data set

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

Returns:

a new VietorisRipsStream object

createVietorisRipsStream

public static <T> VietorisRipsStream<T> createVietorisRipsStream(AbstractSearchableMetricSpace<T> metricSpace,
                                                 int maxDimension,
                                                 double maxFiltrationValue,
                                                 int numDivisions)

This function creates a Vietoris-Rips complex from a metric space.

Type Parameters:

T -

Parameters:

metricSpace - the metric space

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

numDivisions - the number of divisions to use in the filtration

Returns:

a new VietorisRipsStream object

createVietorisRipsStream

public static <T> VietorisRipsStream<T> createVietorisRipsStream(AbstractSearchableMetricSpace<T> metricSpace,
                                                 int maxDimension,
                                                 double maxFiltrationValue)

This function creates a Vietoris-Rips complex given a metric space. It uses 20 as the default number of divisions.

Parameters:

metricSpace - the metric space

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

Returns:

a new VietorisRipsStream object

createVietorisRipsStream

public static VietorisRipsStream<double[]> createVietorisRipsStream(double[][] points,
                                                    int maxDimension,
                                                    double[] filtrationValues)

This function creates a Vietoris-Rips complex given a point cloud.

Parameters:

points - the points in the data set

maxDimension - the maximum simplicial dimension in the complex

filtrationValues - the set of filtration values to use

Returns:

a new VietorisRipsStream object

createVietorisRipsStream

public static <T> VietorisRipsStream<T> createVietorisRipsStream(AbstractSearchableMetricSpace<T> metricSpace,
                                                 int maxDimension,
                                                 double[] filtrationValues)

This function creates a Vietoris-Rips complex from a metric space.

Type Parameters:

T -

Parameters:

metricSpace - the metric space

maxDimension - the maximum simplicial dimension in the complex

filtrationValues - the set of filtration values to use

Returns:

a new VietorisRipsStream object

createLazyWitnessStream

public static LazyWitnessStream<double[]> createLazyWitnessStream(LandmarkSelector<double[]> selector,
                                                  int maxDimension,
                                                  double maxFiltrationValue,
                                                  int numDivisions)

This function create a new lazy-witness stream given a point cloud.

Parameters:

selector - the landmark selection

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

numDivisions - the number of divisions to use in the filtration

Returns:

a new LazyWitnessStream object

createWitnessStream

public static WitnessStream<double[]> createWitnessStream(LandmarkSelector<double[]> selector,
                                          int maxDimension,
                                          double maxFiltrationValue)

This function create a new witness stream given a point cloud. It uses 20 as the default number of divisions.

Parameters:

selector - the landmark selection

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

Returns:

a new LazyWitnessStream object

createWitnessStream

public static WitnessStream<double[]> createWitnessStream(LandmarkSelector<double[]> selector,
                                          int maxDimension,
                                          double maxFiltrationValue,
                                          int numDivisions)

This function create a new witness stream given a point cloud.

Parameters:

selector - the landmark selection

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

numDivisions - the number of divisions to use in the filtration

Returns:

a new LazyWitnessStream object

createLazyWitnessStream

public static LazyWitnessStream<double[]> createLazyWitnessStream(LandmarkSelector<double[]> selector,
                                                  int maxDimension,
                                                  double maxFiltrationValue)

This function create a new lazy-witness stream given a point cloud. It uses 20 as the default number of divisions.

Parameters:

selector - the landmark selection

maxDimension - the maximum simplicial dimension in the complex

maxFiltrationValue - the maximum filtration value

Returns:

a new LazyWitnessStream object

createMaxMinSelector

public static MaxMinLandmarkSelector<double[]> createMaxMinSelector(double[][] points,
                                                    int numLandmarkPoints)

This function creates a new max-min landmark selector on a point cloud.

Parameters:

points - the data set

numLandmarkPoints - the number of points to include in the selection

Returns:

a new MaxMinLandmarkSelector

createMaxMinSelector

public static MaxMinLandmarkSelector<double[]> createMaxMinSelector(double[][] points,
                                                    int numLandmarkPoints,
                                                    int firstPoint)

This function creates a new max-min landmark selector on a point cloud.

Parameters:

points - the data set

numLandmarkPoints - the number of points to include in the selection

firstPoint - the initial point in the landmark set

Returns:

a new MaxMinLandmarkSelector

createRandomSelector

public static RandomLandmarkSelector<double[]> createRandomSelector(double[][] points,
                                                    int numLandmarkPoints)

This function creates a new random landmark point selector on a point cloud.

Parameters:

points - the data set

numLandmarkPoints - the number of points to include in the selection

Returns:

a new RandomLandmarkSelector

createMaxMinSelector

public static <T> MaxMinLandmarkSelector<T> createMaxMinSelector(AbstractSearchableMetricSpace<T> metricSpace,
                                                 int numLandmarkPoints)

This function creates a new max-min landmark selector on an abstract metric space.

Type Parameters:

T - the underlying type of the metric space

Parameters:

metricSpace - the metric space to select from

numLandmarkPoints - the number of points to include in the selection

Returns:

a new MaxMinLandmarkSelector

createMaxMinSelector

public static <T> MaxMinLandmarkSelector<T> createMaxMinSelector(AbstractSearchableMetricSpace<T> metricSpace,
                                                 int numLandmarkPoints,
                                                 int firstPoint)

This function creates a new max-min landmark selector on an abstract metric space.

Type Parameters:

T - the underlying type of the metric space

Parameters:

metricSpace - the metric space to select from

numLandmarkPoints - the number of points to include in the selection

firstPoint - the initial point in the landmark set

Returns:

a new MaxMinLandmarkSelector

createRandomSelector

public static <T> RandomLandmarkSelector<T> createRandomSelector(AbstractSearchableMetricSpace<T> metricSpace,
                                                 int numLandmarkPoints)

This function creates a new randomized landmark selector on an abstract metric space.

Type Parameters:

T - the underlying type of the metric space

Parameters:

metricSpace - the metric space to select from

numLandmarkPoints - the number of points to include in the selection

Returns:

a new RandomLandmarkSelector

createExplicitSelector

public static ExplicitLandmarkSelector<double[]> createExplicitSelector(double[][] points,
                                                        int[] landmarkPoints)

This function creates a new explicit landmark selector on a point cloud.

Parameters:

points - the data set

landmarkPoints - the set of landmark points

Returns:

a new ExplicitLandmarkSelector

createExplicitSelector

public static <T> ExplicitLandmarkSelector<T> createExplicitSelector(AbstractSearchableMetricSpace<T> metricSpace,
                                                     int[] landmarkPoints)

This function creates a new explicit landmark selector on an abstract metric space.

Parameters:

metricSpace - the metric space to select from

landmarkPoints - the set of landmark points

Returns:

a new ExplicitLandmarkSelector

getDefaultSimplicialAlgorithm

public static AbstractPersistenceAlgorithm<Simplex> getDefaultSimplicialAlgorithm(int maxDimension)

This function returns the default (absolute) simplicial persistent homology algorithm.

Parameters:

maxDimension - the maximum dimension the algorithm should compute homology for

Returns:

the default simplicial homology algorithm

getDefaultSimplicialPairAlgorithm

public static AbstractPersistenceAlgorithm<SimplexPair> getDefaultSimplicialPairAlgorithm(int maxDimension)

getDefaultCellularAlgorithm

public static AbstractPersistenceAlgorithm<Cell> getDefaultCellularAlgorithm(int maxDimension)

This function returns the default (absolute) cellular persistent homology algorithm.

Parameters:

maxDimension - the maximum dimension the algorithm should compute homology for

Returns:

the default cellular homology algorithm

getModularCellularAlgorithm

public static AbstractPersistenceAlgorithm<Cell> getModularCellularAlgorithm(int maxDimension,
                                                             int prime)

This function returns a cellular persistence algorithm over the finite field Z/pZ.

Parameters:

maxDimension - the maximum dimension the algorithm should compute homology for

prime - the order of the underlying finite field

Returns:

a cellular homology algorithm over Z/pZ

getModularSimplicialAlgorithm

public static AbstractPersistenceAlgorithm<Simplex> getModularSimplicialAlgorithm(int maxDimension,
                                                                  int prime)

This function returns a simplicial persistence algorithm over the finite field Z/pZ.

Parameters:

maxDimension - the maximum dimension the algorithm should compute homology for

prime - the order of the underlying finite field

Returns:

a simpliciald homology algorithm over Z/pZ

getRationalSimplicialAlgorithm

public static ObjectAbsoluteHomology<org.apache.commons.math.fraction.Fraction,Simplex> getRationalSimplicialAlgorithm(int maxDimension)

This function returns a simplicial persistence algorithm over the the rational numbers.

Parameters:

maxDimension - the maximum dimension the algorithm should compute homology for

Returns:

a simplicial homology algorithm over the rational numbers

getRationalCellularAlgorithm

public static AbstractPersistenceAlgorithm<Cell> getRationalCellularAlgorithm(int maxDimension)

This function returns a cellular persistence algorithm over the the rational numbers.

Parameters:

maxDimension - the maximum dimension the algorithm should compute homology for

Returns:

a cellular homology algorithm over the rational numbers

createBarcodePlot

public static <G> void createBarcodePlot(PersistenceInvariantDescriptor<Interval<java.lang.Double>,G> collection,
                         java.lang.String caption,
                         double endPoint)
                              throws java.io.IOException

This function creates an images of a collection of barcodes and writes it to a file.

Parameters:

collection - the collection of barcodes

caption - the caption for the image

endPoint - the maximum endpoint

Throws:

java.io.IOException

createHomStream

public static <T,U> HomStream<T,U> createHomStream(AbstractFilteredStream<T> domainStream,
                                   AbstractFilteredStream<U> codomainStream)

This function creates a new hom stream from two given filtered streams.

Type Parameters:

T - basis type for the first complex

U - the basis type for the second complex

Parameters:

domainStream - the domain complex

codomainStream - the codomain complex

Returns:

a new hom complex stream

getRationalHomAlgorithm

public static ObjectPersistenceAlgorithm<org.apache.commons.math.fraction.Fraction,edu.stanford.math.primitivelib.autogen.pair.ObjectObjectPair<Simplex,Simplex>> getRationalHomAlgorithm()

This function creates a persistent homology algorithm over the rationals for computing homology of simplicial hom complexes.

Returns:

a persistent homology algorithm

createHomMatrixConverter

public static edu.stanford.math.primitivelib.autogen.formal_sum.DoubleMatrixConverter<Simplex,Simplex> createHomMatrixConverter(AbstractFilteredStream<Simplex> domainStream,
                                                                                                                AbstractFilteredStream<Simplex> codomainStream)

This function creates a matrix converter object for converting between formal sums, sparse and dense matrices.

Parameters:

domainStream - the stream which provides the basis elements for the domain

codomainStream - the stream which provides the basis elements for the codomain

Returns:

a DoubleMatrixConverter

createMatrixConverter

public static edu.stanford.math.primitivelib.autogen.formal_sum.DoubleVectorConverter<Simplex> createMatrixConverter(AbstractFilteredStream<Simplex> stream)

This function creates a vector converter for converting between formal sums, and sparse and dense arrays.

Parameters:

stream - the stream which provides the basis elements

Returns:

a DoubleVectorConverter