Full Code of appliedtopology/javaplex for AI

gitextract_rvwgklfn/

├── .classpath
├── .gitignore
├── .project
├── .settings/
│   ├── org.eclipse.jdt.core.prefs
│   └── org.eclipse.jdt.ui.prefs
├── .travis.yml
├── LICENSE.md
├── README.md
├── build/
│   └── processing/
│       └── javaplex/
│           └── library.properties
├── build.number
├── build.xml
├── data/
│   ├── natural_images/
│   │   ├── n50000Dct.mat
│   │   ├── nk15c30Dct.mat
│   │   ├── nk300c30Dct.mat
│   │   └── readme_natural_images.txt
│   ├── point_clouds/
│   │   ├── circle.txt
│   │   ├── cube.txt
│   │   ├── cylinder.txt
│   │   ├── octahedron.txt
│   │   ├── sphere_rnd.txt
│   │   └── torus.txt
│   └── range_images/
│       ├── pointsRange.mat
│       └── r3_50000.mat
├── doc_includes/
│   ├── overview.htm
│   ├── overview_plex3.htm
│   └── update_mime_types.sh
├── reports/
│   └── javaplex_tutorial/
│       ├── cleanup.sh
│       ├── javaplex_tutorial.aux
│       ├── javaplex_tutorial.bbl
│       ├── javaplex_tutorial.bib
│       ├── javaplex_tutorial.blg
│       ├── javaplex_tutorial.log
│       ├── javaplex_tutorial.out
│       ├── javaplex_tutorial.tex
│       └── javaplex_tutorial.toc
├── src/
│   ├── bsh/
│   │   ├── desktop.bsh
│   │   ├── getBshPrompt.bsh
│   │   ├── makeListener.bsh
│   │   ├── makeWorkspace.bsh
│   │   └── printBanner.bsh
│   ├── cpp/
│   │   ├── Makefile
│   │   └── PLEX3/
│   │       ├── DESCRIPTION
│   │       ├── R/
│   │       │   ├── .plex.R.swp
│   │       │   ├── plex.R
│   │       │   └── zzz.R
│   │       ├── autom4te.cache/
│   │       │   ├── output.0
│   │       │   ├── requests
│   │       │   └── traces.0
│   │       ├── config.guess
│   │       ├── config.status
│   │       ├── config.sub
│   │       ├── configure
│   │       ├── configure.ac
│   │       ├── install-sh
│   │       ├── man/
│   │       │   └── rips.stream.Rd
│   │       └── src/
│   │           ├── Makevars.in
│   │           └── rbind_jni.cpp
│   ├── java/
│   │   ├── bsh/
│   │   │   ├── JPlex.java
│   │   │   ├── JTerm.java
│   │   │   ├── PlexInterpreter.java
│   │   │   ├── PlexReader.java
│   │   │   └── commands/
│   │   │       ├── log.java
│   │   │       └── setLogging.java
│   │   └── edu/
│   │       └── stanford/
│   │           └── math/
│   │               ├── clustering/
│   │               │   ├── DisjointSetSystem.java
│   │               │   ├── HierarchicalClustering.java
│   │               │   ├── LinkageTree.java
│   │               │   └── SingleLinkageClustering.java
│   │               ├── mapper/
│   │               │   ├── BoundedIntervalCover.java
│   │               │   ├── FilterFunctionUtility.java
│   │               │   ├── FiniteMetricSpaceCover.java
│   │               │   ├── HistogramCreator.java
│   │               │   ├── MapperPipeline.java
│   │               │   ├── MapperSpecifier.java
│   │               │   ├── MetricUtility.java
│   │               │   ├── RangeCoverUtility.java
│   │               │   └── SetCover1D.java
│   │               ├── plex/
│   │               │   ├── BCPlot.java
│   │               │   ├── CRC.java
│   │               │   ├── Chain.java
│   │               │   ├── Cone.java
│   │               │   ├── DiscreteSpace.java
│   │               │   ├── DistanceData.java
│   │               │   ├── EuclideanArrayData.java
│   │               │   ├── ExplicitStream.java
│   │               │   ├── LazyWitnessStream.java
│   │               │   ├── MappedBufferData.java
│   │               │   ├── Packed2Simplex.java
│   │               │   ├── Packed4Simplex.java
│   │               │   ├── Packed6Simplex.java
│   │               │   ├── Packed8Simplex.java
│   │               │   ├── Persistence.java
│   │               │   ├── PersistenceBasis.java
│   │               │   ├── PersistenceBasisInterval.java
│   │               │   ├── PersistenceInterval.java
│   │               │   ├── Plex.java
│   │               │   ├── PlexMessageWindow.java
│   │               │   ├── PlexSort.java
│   │               │   ├── PointData.java
│   │               │   ├── RDirectBufferData.java
│   │               │   ├── RipsStream.java
│   │               │   ├── Simplex.java
│   │               │   ├── SimplexFaceIterator.java
│   │               │   ├── SimplexStream.java
│   │               │   ├── SimplexTable.java
│   │               │   ├── TmpStream.java
│   │               │   ├── Torus.java
│   │               │   └── WitnessStream.java
│   │               └── plex4/
│   │                   ├── api/
│   │                   │   ├── FilteredStreamInterface.java
│   │                   │   ├── PersistenceAlgorithmInterface.java
│   │                   │   └── Plex4.java
│   │                   ├── autogen/
│   │                   │   └── homology/
│   │                   │       ├── BooleanAbsoluteHomology.java
│   │                   │       ├── BooleanClassicalHomology.java
│   │                   │       ├── BooleanPersistenceAlgorithm.java
│   │                   │       ├── BooleanPersistentHomology.java
│   │                   │       ├── BooleanRelativeHomology.java
│   │                   │       ├── IntAbsoluteHomology.java
│   │                   │       ├── IntClassicalHomology.java
│   │                   │       ├── IntPersistenceAlgorithm.java
│   │                   │       ├── IntPersistentHomology.java
│   │                   │       ├── IntRelativeHomology.java
│   │                   │       ├── ObjectAbsoluteHomology.java
│   │                   │       ├── ObjectClassicalHomology.java
│   │                   │       ├── ObjectPersistenceAlgorithm.java
│   │                   │       ├── ObjectPersistentHomology.java
│   │                   │       └── ObjectRelativeHomology.java
│   │                   ├── bottleneck/
│   │                   │   ├── BottleneckDistance.java
│   │                   │   ├── FlowEdge.java
│   │                   │   ├── FlowNetwork.java
│   │                   │   ├── FordFulkerson.java
│   │                   │   ├── FordFulkersonEdge.java
│   │                   │   ├── FordFulkersonNode.java
│   │                   │   └── WeightedBipartiteGraph.java
│   │                   ├── examples/
│   │                   │   ├── CellComplexOperations.java
│   │                   │   ├── CellStreamExamples.java
│   │                   │   ├── DeSilvaMorozovJohanssonExample.java
│   │                   │   ├── PointCloudExamples.java
│   │                   │   ├── SimplexStreamExamples.java
│   │                   │   └── SimplicialComplexOperations.java
│   │                   ├── generation/
│   │                   │   └── GeneratorDriver.java
│   │                   ├── graph/
│   │                   │   ├── AbstractUndirectedGraph.java
│   │                   │   ├── AbstractWeightedUndirectedGraph.java
│   │                   │   ├── UndirectedListEdgeIterator.java
│   │                   │   ├── UndirectedListGraph.java
│   │                   │   ├── UndirectedWeightedListGraph.java
│   │                   │   ├── io/
│   │                   │   │   └── GraphDotWriter.java
│   │                   │   ├── metric/
│   │                   │   │   ├── GraphMetricFactory.java
│   │                   │   │   └── ShortestPathMetric.java
│   │                   │   ├── random/
│   │                   │   │   ├── BAGraph.java
│   │                   │   │   ├── BinaryHierarchicalGraph.java
│   │                   │   │   ├── BinaryTree.java
│   │                   │   │   ├── BinaryTreeGraph.java
│   │                   │   │   ├── CircleGraph.java
│   │                   │   │   ├── ClusteredERGraph.java
│   │                   │   │   ├── ErdosRenyiGraph.java
│   │                   │   │   ├── ForestFireGraph.java
│   │                   │   │   ├── GraphInstanceGenerator.java
│   │                   │   │   ├── HierarchicalERGraph.java
│   │                   │   │   ├── KNearestNeighborsGraph.java
│   │                   │   │   ├── ManifoldGraph.java
│   │                   │   │   ├── PrescribedDegrees.java
│   │                   │   │   ├── RandomGeometricGraph.java
│   │                   │   │   ├── SphereGraph.java
│   │                   │   │   ├── StochasticBlockmodel.java
│   │                   │   │   └── TorusGraph.java
│   │                   │   └── utility/
│   │                   │       └── GraphUtility.java
│   │                   ├── homology/
│   │                   │   ├── barcodes/
│   │                   │   │   ├── AnnotatedBarcodeCollection.java
│   │                   │   │   ├── BarcodeCollection.java
│   │                   │   │   ├── BarcodeUtility.java
│   │                   │   │   ├── Interval.java
│   │                   │   │   ├── IntervalLengthComparator.java
│   │                   │   │   └── PersistenceInvariantDescriptor.java
│   │                   │   ├── chain_basis/
│   │                   │   │   ├── Cell.java
│   │                   │   │   ├── CellComparator.java
│   │                   │   │   ├── PrimitiveBasisElement.java
│   │                   │   │   ├── Simplex.java
│   │                   │   │   ├── SimplexComparator.java
│   │                   │   │   ├── SimplexPair.java
│   │                   │   │   └── SimplexPairComparator.java
│   │                   │   ├── filtration/
│   │                   │   │   ├── ExternalConverter.java
│   │                   │   │   ├── FiltrationConverter.java
│   │                   │   │   ├── FiltrationUtility.java
│   │                   │   │   ├── IdentityConverter.java
│   │                   │   │   ├── IncreasingLinearConverter.java
│   │                   │   │   └── StaticConverter.java
│   │                   │   ├── interfaces/
│   │                   │   │   ├── AbstractPersistenceAlgorithm.java
│   │                   │   │   └── AbstractPersistenceBasisAlgorithm.java
│   │                   │   ├── nonautogen/
│   │                   │   │   ├── DisjointSetSystem.java
│   │                   │   │   └── PersistentCohomologyPrototype.java
│   │                   │   ├── utility/
│   │                   │   │   └── HomologyUtility.java
│   │                   │   └── zigzag/
│   │                   │       ├── AbstractHomologyTracker.java
│   │                   │       ├── AbstractPersistenceTracker.java
│   │                   │       ├── BasisTrackingUtility.java
│   │                   │       ├── HomologyBasisTracker.java
│   │                   │       ├── IntervalDescriptor.java
│   │                   │       ├── IntervalTracker.java
│   │                   │       ├── SimpleHomologyBasisTracker.java
│   │                   │       ├── ZigZagHomology.java
│   │                   │       └── bootstrap/
│   │                   │           ├── InducedHomologyMappingUtility.java
│   │                   │           ├── SimplexStreamUtility.java
│   │                   │           ├── VietorisRipsBootstrapper.java
│   │                   │           └── WitnessBootstrapper.java
│   │                   ├── interop/
│   │                   │   ├── Plex3PersistenceAlgorithm.java
│   │                   │   ├── Plex3Stream.java
│   │                   │   ├── Plex3ToPlex4BarcodeAdapter.java
│   │                   │   └── Plex3ToPlex4SimplexAdapter.java
│   │                   ├── io/
│   │                   │   ├── BarcodeWriter.java
│   │                   │   ├── BufferedImageWriter.java
│   │                   │   ├── DoubleArrayReaderWriter.java
│   │                   │   ├── FileIOUtility.java
│   │                   │   ├── FileManager.java
│   │                   │   ├── MatlabInterface.java
│   │                   │   ├── MatlabWriter.java
│   │                   │   ├── ObjReader.java
│   │                   │   ├── ObjectReader.java
│   │                   │   ├── ObjectWriter.java
│   │                   │   ├── SimplexStreamReaderWriter.java
│   │                   │   └── Table.java
│   │                   ├── kd/
│   │                   │   ├── KDEuclideanMetricSpace.java
│   │                   │   ├── KDNode.java
│   │                   │   └── KDTree.java
│   │                   ├── metric/
│   │                   │   ├── impl/
│   │                   │   │   ├── EuclideanMetricSpace.java
│   │                   │   │   ├── ExplicitMetricSpace.java
│   │                   │   │   ├── ObjectSearchableFiniteMetricSpace.java
│   │                   │   │   └── TruncatedPriorityQueue.java
│   │                   │   ├── interfaces/
│   │                   │   │   ├── AbstractIntMetricSpace.java
│   │                   │   │   ├── AbstractObjectMetric.java
│   │                   │   │   ├── AbstractObjectMetricSpace.java
│   │                   │   │   └── AbstractSearchableMetricSpace.java
│   │                   │   ├── landmark/
│   │                   │   │   ├── ExplicitLandmarkSelector.java
│   │                   │   │   ├── LandmarkSelector.java
│   │                   │   │   ├── MaxMinLandmarkSelector.java
│   │                   │   │   └── RandomLandmarkSelector.java
│   │                   │   └── utility/
│   │                   │       ├── DensityEstimation.java
│   │                   │       └── MetricUtility.java
│   │                   ├── streams/
│   │                   │   ├── derived/
│   │                   │   │   ├── DualStream.java
│   │                   │   │   ├── HomStream.java
│   │                   │   │   ├── TensorStream.java
│   │                   │   │   └── TruncatedStream.java
│   │                   │   ├── filter/
│   │                   │   │   ├── EccentricityFilterFunction.java
│   │                   │   │   ├── ExplicitIntFilterFunction.java
│   │                   │   │   ├── FilterFunction.java
│   │                   │   │   ├── IntFilterFunction.java
│   │                   │   │   ├── KernelDensityFilterFunction.java
│   │                   │   │   ├── MaxSimplicialFilterFunction.java
│   │                   │   │   ├── MinSimplicialFilterFunction.java
│   │                   │   │   └── RandomProjectionFilterFunction.java
│   │                   │   ├── impl/
│   │                   │   │   ├── ExplicitCellStream.java
│   │                   │   │   ├── ExplicitSimplexStream.java
│   │                   │   │   ├── ExplicitStream.java
│   │                   │   │   ├── FlagComplexStream.java
│   │                   │   │   ├── FlexibleVietorisRipsStream.java
│   │                   │   │   ├── GeometricSimplexStream.java
│   │                   │   │   ├── LazyWitnessStream.java
│   │                   │   │   ├── VietorisRipsStream.java
│   │                   │   │   ├── WitnessBicomplex.java
│   │                   │   │   └── WitnessStream.java
│   │                   │   ├── interfaces/
│   │                   │   │   ├── AbstractFilteredStream.java
│   │                   │   │   └── PrimitiveStream.java
│   │                   │   ├── multi/
│   │                   │   │   ├── AbstractMultifilteredStream.java
│   │                   │   │   ├── AbstractStreamFlattener.java
│   │                   │   │   ├── BifilteredMetricStream.java
│   │                   │   │   ├── HalfplaneFlattener.java
│   │                   │   │   ├── IncreasingOrthantFlattener.java
│   │                   │   │   └── PrimitiveMultifilteredStream.java
│   │                   │   ├── storage_structures/
│   │                   │   │   ├── HashedStorageStructure.java
│   │                   │   │   ├── HashedStorageStructureIterator.java
│   │                   │   │   ├── IntOrderedIterator.java
│   │                   │   │   ├── SortedStorageStructure.java
│   │                   │   │   ├── StreamStorageStructure.java
│   │                   │   │   └── StreamStorageStructureFactory.java
│   │                   │   └── utility/
│   │                   │       ├── FilteredComparator.java
│   │                   │       ├── SkeletalMetric.java
│   │                   │       └── StreamUtility.java
│   │                   ├── utility/
│   │                   │   ├── ArrayUtility.java
│   │                   │   ├── CollectionUtility.java
│   │                   │   ├── ComparisonUtility.java
│   │                   │   ├── ExceptionUtility.java
│   │                   │   ├── FormalSumUtility.java
│   │                   │   ├── MathUtility.java
│   │                   │   ├── MemoryUtility.java
│   │                   │   ├── Quicksort.java
│   │                   │   └── RandomUtility.java
│   │                   └── visualization/
│   │                       ├── AbstractVisualizer.java
│   │                       ├── BarcodeVisualizer.java
│   │                       ├── HomologyGeneratorVisualizer.java
│   │                       ├── HomologyVisualizer.java
│   │                       ├── ImageRegion.java
│   │                       ├── PAppletSplitscreen.java
│   │                       ├── Point2D.java
│   │                       └── PointCloudScaling.java
│   ├── matlab/
│   │   ├── experimental/
│   │   │   ├── graph_classification/
│   │   │   │   ├── ad_health_example.m
│   │   │   │   ├── ad_health_plot.m
│   │   │   │   ├── average_block_matrix.m
│   │   │   │   ├── blockmodel_er_test.m
│   │   │   │   ├── blockmodel_test.m
│   │   │   │   ├── blockmodel_test2.m
│   │   │   │   ├── comparative_barcode_analysis.m
│   │   │   │   ├── comparative_graph_analysis.m
│   │   │   │   ├── comprehensive_test.m
│   │   │   │   ├── compute_adjacency_matrix.m
│   │   │   │   ├── compute_normalized_laplacian.m
│   │   │   │   ├── create_graph_from_edgelist.m
│   │   │   │   ├── er_test.m
│   │   │   │   ├── er_test_increasing_sizes.m
│   │   │   │   ├── filter_distance_matrix.m
│   │   │   │   ├── get_adhealth_edges16.m
│   │   │   │   ├── get_adhealth_edges44.m
│   │   │   │   ├── get_adhealth_edges47.m
│   │   │   │   ├── heatmap.m
│   │   │   │   ├── heatmap_examples.m
│   │   │   │   ├── hetergeneous_test.m
│   │   │   │   ├── pairwise_barcode_analysis.m
│   │   │   │   ├── pairwise_graph_analysis.m
│   │   │   │   ├── pairwise_row_distances.m
│   │   │   │   ├── plot_example.m
│   │   │   │   ├── plot_graph.m
│   │   │   │   ├── random_geometric_graph.m
│   │   │   │   ├── random_geometric_test.m
│   │   │   │   ├── rg_plot_example.m
│   │   │   │   ├── sandbox.m
│   │   │   │   ├── spectral_embedding.m
│   │   │   │   ├── torus_geometric.m
│   │   │   │   ├── visualize_comparison_distances.m
│   │   │   │   └── visualize_dissimilarity_matrix.m
│   │   │   ├── hom/
│   │   │   │   ├── combinatorial/
│   │   │   │   │   ├── brute_force_test.m
│   │   │   │   │   ├── flip_random_entry.m
│   │   │   │   │   ├── get_binary_subsets.m
│   │   │   │   │   ├── greedy_search.m
│   │   │   │   │   ├── greedy_search_test.m
│   │   │   │   │   ├── hom_parameterization_example.m
│   │   │   │   │   ├── simmulated_annealing_test.m
│   │   │   │   │   └── simulated_annealing.m
│   │   │   │   ├── continuous/
│   │   │   │   │   ├── circle_example.m
│   │   │   │   │   ├── create_max_lp.m
│   │   │   │   │   ├── create_positive_lp.m
│   │   │   │   │   ├── create_positive_lp2.m
│   │   │   │   │   └── tetra_octa_example.m
│   │   │   │   ├── hom_utility/
│   │   │   │   │   ├── compute_mapping.m
│   │   │   │   │   ├── default_objective.m
│   │   │   │   │   └── hom_parameterization.m
│   │   │   │   └── load_hom.m
│   │   │   ├── hom_messy/
│   │   │   │   ├── L2_distance.m
│   │   │   │   ├── alexander_whitney_difference.m
│   │   │   │   ├── alexander_whitney_loss_function.m
│   │   │   │   ├── circle_distance.m
│   │   │   │   ├── codomain_points.txt
│   │   │   │   ├── codomain_stream.txt
│   │   │   │   ├── colorGraph.m
│   │   │   │   ├── compute_interpolated_points.m
│   │   │   │   ├── compute_mapping.m
│   │   │   │   ├── convert_sparse_matrix.m
│   │   │   │   ├── create_max_lp.m
│   │   │   │   ├── create_positive_lp.m
│   │   │   │   ├── create_quotient_complex.m
│   │   │   │   ├── create_quotient_mapper_complex.m
│   │   │   │   ├── density_at_point.m
│   │   │   │   ├── density_function.m
│   │   │   │   ├── density_maximization_test.m
│   │   │   │   ├── density_objective.m
│   │   │   │   ├── domain_points.txt
│   │   │   │   ├── domain_stream.txt
│   │   │   │   ├── embedding_optimization_test.asv
│   │   │   │   ├── embedding_optimization_test.m
│   │   │   │   ├── embedding_optimization_test2.m
│   │   │   │   ├── fast_kron_mult.m
│   │   │   │   ├── flatten.m
│   │   │   │   ├── floyd_warshall.m
│   │   │   │   ├── gaussian_kernel_densities.m
│   │   │   │   ├── gaussian_kernel_density.m
│   │   │   │   ├── get_edges.m
│   │   │   │   ├── gradient.m
│   │   │   │   ├── graph_embedding.m
│   │   │   │   ├── hom_example_test.m
│   │   │   │   ├── hom_optimization_example.m
│   │   │   │   ├── hom_parameterization.m
│   │   │   │   ├── hom_visualization_example.m
│   │   │   │   ├── kron_test.m
│   │   │   │   ├── load_javaplex.m
│   │   │   │   ├── mapper.m
│   │   │   │   ├── mapperTutorial.m
│   │   │   │   ├── mapper_mapping_test.m
│   │   │   │   ├── mapping.txt
│   │   │   │   ├── matrix.txt
│   │   │   │   ├── normalize_rows.m
│   │   │   │   ├── objectivize.m
│   │   │   │   ├── pdist2.m
│   │   │   │   ├── returnBarCode_linkage_noplex.m
│   │   │   │   ├── show_graph.m
│   │   │   │   ├── smoothness_objective.m
│   │   │   │   ├── test_aw_optimization.m
│   │   │   │   ├── to_graph.m
│   │   │   │   ├── to_sparse_matlab_matrix.m
│   │   │   │   ├── unflatten.m
│   │   │   │   └── writeDotFile.m
│   │   │   ├── multifiltration_flattening/
│   │   │   │   ├── Syn2d_5g1k3c.mat
│   │   │   │   ├── Syn2d_5g1k3c_c1.txt
│   │   │   │   ├── clustering_example.m
│   │   │   │   └── flattened_clusters.eps
│   │   │   ├── vietoris_rips_bootstrap/
│   │   │   │   ├── basic_circle_example.m
│   │   │   │   ├── basic_sphere_example.m
│   │   │   │   ├── circle_incremental.m
│   │   │   │   ├── circle_long.m
│   │   │   │   ├── coreSubset.m
│   │   │   │   ├── core_subset_test.m
│   │   │   │   ├── core_verification_test.m
│   │   │   │   ├── ensure_density_indices.m
│   │   │   │   ├── figure_8_incremental.m
│   │   │   │   ├── filtered_barcodes.m
│   │   │   │   ├── filtered_bootstrap.m
│   │   │   │   ├── gaussian_kernel_densities.m
│   │   │   │   ├── gaussian_kernel_density.m
│   │   │   │   ├── get_cache_file_path.m
│   │   │   │   ├── get_core_subset_cached.m
│   │   │   │   ├── get_data_file_path.m
│   │   │   │   ├── kDensitySlow.m
│   │   │   │   ├── load_density_indices.m
│   │   │   │   ├── natural_samples_bootstrap_example.m
│   │   │   │   ├── natural_samples_example.m
│   │   │   │   ├── nk15c30Dct_LW0.m
│   │   │   │   ├── nk15c30Dct_LW1.m
│   │   │   │   ├── nk15c30Dct_VR.m
│   │   │   │   ├── nk300c30Dct_LW0.m
│   │   │   │   ├── nk300c30Dct_LW1.m
│   │   │   │   ├── nk300c30Dct_VR.m
│   │   │   │   ├── outputs/
│   │   │   │   │   ├── n50000Dct-15-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-300-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-10-20-1-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-13-17-1-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-15-45-5-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-15-450-15-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-2-400-1-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-25-350-25-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-300-350-25-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-400-800-25-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-5-100-5-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-5-25-1-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-5-400-5-15000-1.100.eps
│   │   │   │   │   ├── n50000Dct-samples-5-50-5-15000-1.100.eps
│   │   │   │   │   └── nk300c30Dct_LW0.eps
│   │   │   │   └── parfor_test.m
│   │   │   └── witness_bootstrap/
│   │   │       ├── circle_example.m
│   │   │       ├── circle_incremental.m
│   │   │       ├── circle_pairwise.m
│   │   │       ├── figure8_example.m
│   │   │       ├── figure8_incremental.m
│   │   │       ├── figure8_pairwise.m
│   │   │       ├── figure8_samples.m
│   │   │       ├── image_patch_examples.m
│   │   │       └── torus_example.m
│   │   └── for_distribution/
│   │       ├── README
│   │       ├── basic_examples/
│   │       │   ├── barcode_plot_example.m
│   │       │   ├── boundary_extraction_example.m
│   │       │   ├── cellular_test.m
│   │       │   ├── dump_example.m
│   │       │   ├── endpoint_extraction_example.m
│   │       │   ├── ensure_faces_test.m
│   │       │   ├── explicit_metric_space_test.m
│   │       │   ├── explicit_simplex_test.m
│   │       │   ├── explicit_simplex_test2.m
│   │       │   ├── filter_long_intervals.m
│   │       │   ├── house_example_test.m
│   │       │   ├── landmark_test.m
│   │       │   ├── representatives_example.m
│   │       │   ├── simplicial_sphere_test.m
│   │       │   ├── sphere_test.m
│   │       │   └── vietoris_rips_example.m
│   │       ├── benchmarks/
│   │       │   └── rips_persistence.m
│   │       ├── jython/
│   │       │   ├── basic_vr_example.jy
│   │       │   ├── cellular_example.jy
│   │       │   ├── explicit_simplex_example.jy
│   │       │   ├── image_patch_example.jy
│   │       │   ├── pointsRange.csv
│   │       │   ├── quick_povray.sh
│   │       │   ├── representatives_example.jy
│   │       │   ├── sphere_witness_example.jy
│   │       │   ├── torus_witness_example.jy
│   │       │   └── visualization_example.jy
│   │       ├── load_javaplex.m
│   │       ├── tutorial_examples/
│   │       │   ├── bottleneck_distance_example.m
│   │       │   ├── coreSubset.m
│   │       │   ├── core_subsets_example.m
│   │       │   ├── cyclo_octane_example.m
│   │       │   ├── dct.m
│   │       │   ├── eulerCharacteristic.m
│   │       │   ├── euler_characteristic_example.m
│   │       │   ├── explicit_metric_space_example.m
│   │       │   ├── explicit_simplex_example.m
│   │       │   ├── house_example.m
│   │       │   ├── kDensitySlow.m
│   │       │   ├── landmark_example.m
│   │       │   ├── lazy_witness_example.m
│   │       │   ├── optical_image_example.m
│   │       │   ├── pointcloud_example.m
│   │       │   ├── pointsCycloOctane.mat
│   │       │   ├── pointsOpticalDct_k15.mat
│   │       │   ├── pointsOpticalDct_k300.mat
│   │       │   ├── pointsRange.mat
│   │       │   ├── pointsTorusGrid.mat
│   │       │   ├── range_image_example.m
│   │       │   ├── rips_example.m
│   │       │   ├── sublevelset_example.m
│   │       │   ├── sublevelset_persistence.m
│   │       │   └── witness_example.m
│   │       ├── tutorial_solutions/
│   │       │   ├── exercise_1.m
│   │       │   ├── exercise_11.m
│   │       │   ├── exercise_12.m
│   │       │   ├── exercise_13.m
│   │       │   ├── exercise_14.m
│   │       │   ├── exercise_2.m
│   │       │   ├── exercise_21.m
│   │       │   ├── exercise_22.m
│   │       │   ├── exercise_23.m
│   │       │   ├── exercise_24.m
│   │       │   ├── exercise_3.m
│   │       │   ├── exercise_4.m
│   │       │   ├── exercise_5.m
│   │       │   ├── exercise_6.m
│   │       │   ├── exercise_7.m
│   │       │   ├── exercise_8.m
│   │       │   ├── exercise_9.m
│   │       │   ├── flatKleinDistanceMatrix.m
│   │       │   ├── flatTorusDistanceMatrix.m
│   │       │   ├── getDoubleTorusPoints.m
│   │       │   └── projPlaneDistanceMatrix.m
│   │       ├── utility/
│   │       │   ├── convert_sparse_matrix.m
│   │       │   ├── create_landmark_pov_file.m
│   │       │   ├── create_pov_file.m
│   │       │   ├── flatten.m
│   │       │   ├── persistence_diagram.m
│   │       │   ├── plot_barcodes.m
│   │       │   ├── render_onscreen.m
│   │       │   ├── render_pov_file.m
│   │       │   └── to_sparse_matlab_matrix.m
│   │       └── visualization_examples/
│   │           ├── landmark_set_pov.m
│   │           ├── witness_sphere_opengl.m
│   │           └── witness_sphere_pov.m
│   └── processing/
│       ├── javaplex/
│       │   └── library.properties
│       ├── javaplexDemo/
│       │   ├── State.java
│       │   └── javaplexDemo.pde
│       └── readme.txt
├── src_test/
│   └── java/
│       └── edu/
│           └── stanford/
│               └── math/
│                   ├── mapper/
│                   │   ├── ClusteringTest.java
│                   │   ├── HistogramTest.java
│                   │   └── MapperTest.java
│                   ├── plex/
│                   │   ├── CRCTest.java
│                   │   ├── ChainTest.java
│                   │   ├── CubeHashTest.java
│                   │   ├── ExplicitStreamTest.java
│                   │   ├── LazyWitnessStreamTest.java
│                   │   ├── MappedBufferDataTest.java
│                   │   ├── Packed2SimplexTest.java
│                   │   ├── Packed4SimplexTest.java
│                   │   ├── Packed6SimplexTest.java
│                   │   ├── PersistenceBasisTest.java
│                   │   ├── PersistenceIntervalTest.java
│                   │   ├── PersistenceTest.java
│                   │   ├── PlexSortTest.java
│                   │   ├── PlexTest.java
│                   │   ├── RipsStreamTest.java
│                   │   ├── SimplexFaceIteratorTest.java
│                   │   ├── SimplexTableTest.java
│                   │   ├── SimplexTest.java
│                   │   ├── TorusTest.java
│                   │   └── WitnessStreamTest.java
│                   └── plex4/
│                       ├── bottleneck/
│                       │   ├── BottleneckDistanceTest.java
│                       │   └── FordFulkersonTest.java
│                       ├── example_tests/
│                       │   ├── CustomFiltrationTest.java
│                       │   ├── FiltrationTimeTest.java
│                       │   ├── FormalSumTest.java
│                       │   ├── GraphTest.java
│                       │   ├── HomVerificationTest.java
│                       │   ├── MultifilteredFlatteningTest.java
│                       │   ├── VdsWitnessExample.java
│                       │   ├── VietorisRipsBootstrapTest.java
│                       │   ├── WitnessBootstrapTest.java
│                       │   └── ZigZagTest.java
│                       ├── homology/
│                       │   ├── HomTester.java
│                       │   ├── PersistenceAlgorithmTester.java
│                       │   └── StreamTester.java
│                       ├── metric/
│                       │   └── SearchableMetricSpaceTester.java
│                       ├── test_utility/
│                       │   └── Timing.java
│                       └── unit_tests/
│                           ├── DeSilvaMorozovJohanssonTest.java
│                           ├── ExperimentalEqualityTest.java
│                           ├── PersistenceAlgorithmEqualityTest.java
│                           ├── SearchableMetricSpaceTest.java
│                           ├── SimplicialSphereTest.java
│                           └── StreamsTest.java
└── templates/
    └── homology/
        ├── AbsoluteHomology.vm
        ├── ClassicalHomology.vm
        ├── PersistenceAlgorithm.vm
        ├── PersistentHomology.vm
        └── RelativeHomology.vm

SYMBOL INDEX (2711 symbols across 281 files)

FILE: src/cpp/PLEX3/src/rbind_jni.cpp
  function intmap_keycompare (line 16) | bool intmap_keycompare(std::pair<int, T> a, std::pair<int, T> b)
  function SEXP (line 43) | SEXP init_java(SEXP classpath) {
  function SEXP (line 117) | SEXP R_exception()
  function matrix_finalizer (line 132) | static void matrix_finalizer(SEXP handle)
  function java_data_ref_finalizer (line 138) | static void java_data_ref_finalizer(SEXP handle)
  function java_stream_ref_finalizer (line 145) | static void java_stream_ref_finalizer(SEXP handle)
  function jobject (line 153) | jobject create_direct_buffer(SEXP matrix, SEXP buflen)
  function SEXP (line 192) | SEXP register_stream(jobject stream)
  function SEXP (line 223) | SEXP register_pointdata(jobject pdata)
  function SEXP (line 254) | SEXP make_internal_distance_array(SEXP dmatrix, SEXP buflen)
  function SEXP (line 272) | SEXP random_euclidean_array_data(SEXP count, SEXP dim)
  function SEXP (line 287) | SEXP make_random_landmarks(SEXP pdata_handle, SEXP landmark_count)
  function SEXP (line 314) | SEXP estimate_r_max(SEXP pdata_handle, SEXP landmarks)
  function SEXP (line 347) | SEXP filter_infinite(SEXP intervals, SEXP intervalcount)
  function SEXP (line 377) | SEXP create_lw_stream_from_handle(SEXP pdata_handle, SEXP granularity, S...
  function SEXP (line 400) | SEXP create_rips_stream(SEXP pdata_handle, SEXP delta, SEXP max_len, SEX...
  function SEXP (line 415) | SEXP create_explicit_stream()
  function SEXP (line 425) | SEXP open_ex_stream(SEXP streamid)
  function SEXP (line 440) | SEXP close_ex_stream(SEXP streamid)
  function SEXP (line 454) | SEXP add_simplex(SEXP streamid, SEXP vertices, SEXP param)
  function SEXP (line 476) | SEXP remove_simplex(SEXP streamid, SEXP vertices)
  function SEXP (line 498) | SEXP get_intervals_from_stream(SEXP streamid)
  function add_class (line 533) | int add_class(std::string classname, std::string classpath) {
  function add_method (line 550) | int add_method(std::string classname, std::string methodname, std::strin...

FILE: src/java/bsh/JPlex.java
  class JPlex (line 37) | public class JPlex {
    method main (line 43) | public static void main( String args[] ) {

FILE: src/java/bsh/JTerm.java
  class JTerm (line 36) | public class JTerm {
    method main (line 42) | public static void main( String args[] ) {

FILE: src/java/bsh/PlexInterpreter.java
  class PlexInterpreter (line 37) | public class PlexInterpreter extends Interpreter {
    method PlexInterpreter (line 49) | public PlexInterpreter(ConsoleInterface console, String name) {
    method PlexInterpreter (line 60) | public PlexInterpreter(String name) {
    method setLogfile (line 69) | public void setLogfile(String logfile_name) {
    method enableLogging (line 78) | public void enableLogging() {
    method logStatus (line 87) | public String logStatus() {
    method disableLogging (line 98) | public void disableLogging() {

FILE: src/java/bsh/PlexReader.java
  class PlexReader (line 45) | public class PlexReader extends FilterReader {
    class Error (line 53) | private static final class Error extends IOException {
      method Error (line 55) | @SuppressWarnings("unused")
      method Error (line 59) | public Error(String message) {
    class ContinuableError (line 65) | private static final class ContinuableError extends IOException {
      method ContinuableError (line 67) | @SuppressWarnings("unused")
      method ContinuableError (line 71) | public ContinuableError(String message) {
    class FatalError (line 77) | private static final class FatalError extends IOException {
      method FatalError (line 79) | @SuppressWarnings("unused")
      method FatalError (line 83) | public FatalError(String message) {
    class CharQ (line 95) | private static final class CharQ {
      method CharQ (line 101) | public CharQ() {
      method reset (line 107) | private void reset() {
      method ensureSpace (line 112) | private final void ensureSpace(int need) {
      method add (line 135) | @SuppressWarnings("unused")
      method bulkAdd (line 141) | public final void bulkAdd(char[] b, int pos, int len) {
      method toString (line 148) | public final String toString() {
      method available (line 155) | public final int available() {
      method hasNext (line 159) | public final boolean hasNext() {
      method char_to_hex (line 163) | static final int char_to_hex(char c) throws FatalError {
      method next (line 175) | public final char next() throws Error {
      method peek (line 182) | public final char peek() throws Error {
      method current (line 189) | public final int current() {
      method rewind (line 193) | public final void rewind(int new_first) {
      method convertNext (line 200) | public final char convertNext() throws Error, ContinuableError, Fata...
    method PlexReader (line 258) | public PlexReader(Reader in, String ws_name) {
    method reset_log_data (line 270) | private void reset_log_data() {
    method log (line 282) | static Reader log(Reader in, String ws_name) {
    method log (line 305) | static Reader log(InputStream in, String ws_name) {
    method createNewFile (line 320) | private static File createNewFile(String prefix,
    method enable (line 341) | public void enable(String log_name) throws IOException {
    method enable (line 361) | final void enable() {
    method disable (line 380) | final void disable() {
    method setLogfile (line 393) | public void setLogfile (String new_log_name) {
    method flush (line 424) | private boolean flush() {
    method convertInput (line 446) | private void convertInput() {
    method log (line 474) | private void log(char[] buf, int off, int len) {
    method read (line 490) | public int read(char[] buf, int off, int len) throws IOException {
    method setDefaultFlag (line 504) | public static void setDefaultFlag(boolean flag) {
    method log_status (line 513) | public String log_status() {
    method setDefaultDir (line 543) | public static void setDefaultDir(String pathname) {

FILE: src/java/bsh/commands/log.java
  class log (line 39) | public class log
    method usage (line 41) | public static String usage() {
    method invoke (line 50) | public static String invoke(Interpreter env, CallStack callstack){
    method invoke (line 61) | public static void invoke(Interpreter env, CallStack callstack, String...
    method invoke (line 72) | public static void invoke(Interpreter env, CallStack callstack,

FILE: src/java/bsh/commands/setLogging.java
  class setLogging (line 38) | public class setLogging
    method usage (line 40) | public static String usage() {
    method invoke (line 48) | public static void invoke(Interpreter env, CallStack callstack, String...
    method invoke (line 55) | public static void invoke(Interpreter env, CallStack callstack,

FILE: src/java/edu/stanford/math/clustering/DisjointSetSystem.java
  class DisjointSetSystem (line 3) | public class DisjointSetSystem {
    method DisjointSetSystem (line 7) | public DisjointSetSystem(int n) {
    method union (line 16) | public void union(int x, int y) {
    method find (line 33) | public int find(int x) {
    method size (line 39) | public int size() {

FILE: src/java/edu/stanford/math/clustering/HierarchicalClustering.java
  class HierarchicalClustering (line 13) | public abstract class HierarchicalClustering {
    method HierarchicalClustering (line 21) | public HierarchicalClustering(AbstractIntMetricSpace metricSpace) {
    method getMergedDistances (line 26) | public double[] getMergedDistances() {
    method getImpliedClusters (line 30) | public static List<Set<Integer>> getImpliedClusters(DisjointSetSystem ...
    method getImpliedClustersTrove (line 48) | public static List<TIntHashSet> getImpliedClustersTrove(DisjointSetSys...
    method thresholdByDistance (line 66) | public DisjointSetSystem thresholdByDistance(double maxDistance) {
    method thresholdByNumClusters (line 81) | public DisjointSetSystem thresholdByNumClusters(int numClusters) {
    method performClustering (line 102) | public abstract void performClustering();

FILE: src/java/edu/stanford/math/clustering/LinkageTree.java
  class LinkageTree (line 3) | public class LinkageTree {

FILE: src/java/edu/stanford/math/clustering/SingleLinkageClustering.java
  class SingleLinkageClustering (line 5) | public class SingleLinkageClustering extends HierarchicalClustering {
    method SingleLinkageClustering (line 7) | public SingleLinkageClustering(AbstractIntMetricSpace metricSpace) {
    method performClustering (line 11) | public void performClustering() {

FILE: src/java/edu/stanford/math/mapper/BoundedIntervalCover.java
  class BoundedIntervalCover (line 9) | public class BoundedIntervalCover implements Iterable<Interval<Double>> {
    method BoundedIntervalCover (line 15) | public BoundedIntervalCover(double min, double max, int n, double over...
    method initialize (line 24) | void initialize() {
    method iterator (line 36) | public Iterator<Interval<Double>> iterator() {

FILE: src/java/edu/stanford/math/mapper/FilterFunctionUtility.java
  class FilterFunctionUtility (line 4) | public class FilterFunctionUtility {

FILE: src/java/edu/stanford/math/mapper/FiniteMetricSpaceCover.java
  class FiniteMetricSpaceCover (line 9) | public class FiniteMetricSpaceCover implements Iterable<TIntHashSet> {
    method FiniteMetricSpaceCover (line 13) | public FiniteMetricSpaceCover(IntFilterFunction filter, AbstractIntMet...
    method iterator (line 19) | public Iterator<TIntHashSet> iterator() {

FILE: src/java/edu/stanford/math/mapper/HistogramCreator.java
  class HistogramCreator (line 3) | public class HistogramCreator {
    method HistogramCreator (line 10) | HistogramCreator(double[] values, int numBins) {
    method performBinning (line 19) | protected int[] performBinning() {
    method getMin (line 36) | protected double getMin() {
    method getMax (line 46) | protected double getMax() {
    method getCounts (line 56) | public int[] getCounts() {
    method getBinLattice (line 60) | protected double[] getBinLattice(double offset) {
    method getBinStartingPoints (line 75) | public double[] getBinStartingPoints() {
    method getBinEndingPoints (line 79) | public double[] getBinEndingPoints() {
    method getBinMidPoints (line 83) | public double[] getBinMidPoints() {
    method getBinStartPoint (line 87) | public double getBinStartPoint(int binIndex) {
    method getBinLatticePoint (line 91) | public double getBinLatticePoint(int binIndex, double offset) {
    method getLastZeroBinIndex (line 100) | public int getLastZeroBinIndex() {
    method generateString (line 109) | protected String generateString(int maxHistogramStars) {
    method repeatString (line 154) | protected static String repeatString(String s, int n) {
    method toString (line 158) | @Override

FILE: src/java/edu/stanford/math/mapper/MapperPipeline.java
  class MapperPipeline (line 18) | public class MapperPipeline {
    method producePartialClustering (line 19) | public static List<TIntHashSet> producePartialClustering(IntFilterFunc...
    method intersectionGraph (line 60) | public static AbstractWeightedUndirectedGraph intersectionGraph(List<T...
    method pullUpIndices (line 80) | protected static TIntHashSet pullUpIndices(TIntHashSet subIndices, TIn...

FILE: src/java/edu/stanford/math/mapper/MapperSpecifier.java
  class MapperSpecifier (line 3) | public class MapperSpecifier {
    method create (line 8) | public static MapperSpecifier create() {
    method numIntervals (line 12) | MapperSpecifier numIntervals(int numIntervals) {
    method overlap (line 17) | MapperSpecifier overlap(double overlap) {
    method numHistogramBuckets (line 22) | MapperSpecifier numHistogramBuckets(int numHistogramBuckets) {

FILE: src/java/edu/stanford/math/mapper/MetricUtility.java
  class MetricUtility (line 6) | public class MetricUtility {
    method createSubMetricSpace (line 7) | public static AbstractIntMetricSpace createSubMetricSpace(final Abstra...
    method createSubMetricSpace (line 21) | public static AbstractIntMetricSpace createSubMetricSpace(final Abstra...

FILE: src/java/edu/stanford/math/mapper/RangeCoverUtility.java
  class RangeCoverUtility (line 6) | public class RangeCoverUtility {
    method createUniformIntervalCover (line 8) | public static Iterable<Interval<Double>> createUniformIntervalCover(In...

FILE: src/java/edu/stanford/math/mapper/SetCover1D.java
  class SetCover1D (line 20) | public class SetCover1D implements Iterable<TIntHashSet> {
    method SetCover1D (line 25) | public SetCover1D(IntFilterFunction filter, Iterable<Interval<Double>>...
    method initialize (line 33) | void initialize() {
    method iterator (line 50) | public Iterator<TIntHashSet> iterator() {

FILE: src/java/edu/stanford/math/plex/BCPlot.java
  class BCPlot (line 44) | public class BCPlot extends JPanel {
    method getMaxDisplayableBars (line 152) | public int getMaxDisplayableBars(){
    method setMajorLegend (line 159) | protected void setMajorLegend(String s){
    method BCPlot (line 163) | protected BCPlot() {
    method BCPlot (line 168) | protected BCPlot(double[][] values, double upperBound, boolean forceSc...
    method illegal_interval_string (line 240) | protected static String illegal_interval_string(int i, double a, doubl...
    method validate (line 249) | protected void validate(double[][] numbers, double upperBound) {
    method initJFrame (line 273) | protected void initJFrame(){
    method createMenuBar (line 310) | protected JMenuBar createMenuBar() {
    method getFormats (line 340) | protected String[] getFormats() {
    class fileSaveMenuHandler (line 352) | protected class fileSaveMenuHandler extends AbstractAction {
      method fileSaveMenuHandler (line 354) | protected fileSaveMenuHandler(String text, ImageIcon icon,
      method actionPerformed (line 364) | public void actionPerformed(ActionEvent e) {
    class DrawingPane (line 387) | protected class DrawingPane extends JPanel {
      method DrawingPane (line 397) | protected DrawingPane(){
      method paintComponent (line 457) | protected void paintComponent(Graphics g) {
      method drawGridLines (line 583) | protected void drawGridLines(Graphics g){
      method drawRuler (line 628) | protected void drawRuler(Graphics g, int position){
      method centerText (line 826) | protected void centerText(String s1, Font f1, FontMetrics m1, Color ...
      method saveImage (line 902) | protected void saveImage(File file, String format){
    class Ruler (line 940) | protected class Ruler extends JComponent {
      method Ruler (line 944) | protected Ruler(DrawingPane bc) {
      method paintComponent (line 949) | protected void paintComponent(Graphics g) {
    method plot (line 964) | protected static void plot(String legend, double[][] values,
    method doPlot (line 996) | public static void doPlot(String label, double[][] intervals, double u...
    method doScatter (line 1020) | public static void doScatter(String label, double[][] intervals, doubl...

FILE: src/java/edu/stanford/math/plex/CRC.java
  class CRC (line 8) | public class CRC {
    method CRC (line 10) | private CRC() {
    method update32l (line 368) | protected static int update32l(long b, int hcode, int[] tbl) {
    method update32 (line 381) | protected static int update32(byte b, int hcode, int[] tbl) {
    method update32 (line 395) | protected static int update32(short s, int hcode, int[] tbl) {
    method update32 (line 410) | protected static int update32(int i, int hcode, int[] tbl) {
    method update32 (line 427) | protected static int update32(long l, int hcode, int[] tbl) {
    method update64l (line 449) | protected static long update64l(long b, long hcode, long[] tbl) {
    method update64 (line 462) | protected static long update64(byte b, long hcode, long[] tbl) {
    method update64 (line 476) | protected static long update64(short s, long hcode, long[] tbl) {
    method update64 (line 491) | protected static long update64(int i, long hcode, long[] tbl) {
    method update64 (line 508) | protected static long update64(long l, long hcode, long[] tbl) {
    method hash64 (line 528) | protected static long hash64(byte[] v) {
    method hash64 (line 544) | public static long hash64(short[] v) {
    method update_hash (line 561) | public static long update_hash(int x, long hcode) {
    method update_hash (line 574) | public static long update_hash(long x, long hcode) {
    method hash64 (line 586) | public static long hash64(int[] v) {
    method hash64 (line 602) | public static long hash64(float[] v) {
    method hash64 (line 619) | public static long hash64(long[] v) {
    method hash64 (line 635) | public static long hash64(double[] v) {
    method hash32 (line 652) | public static int hash32(byte[] v) {
    method hash32 (line 668) | public static int hash32(short[] v) {
    method hash32 (line 684) | public static int hash32(int[] v) {
    method hash32 (line 700) | public static int hash32(float[] v) {
    method hash32 (line 717) | public static int hash32(long[] v) {
    method hash32 (line 733) | public static int hash32(double[] v) {
    method hash32 (line 753) | public static int hash32(double[][] A, int rows, int cols) {
    method hash64 (line 776) | public static long hash64(long x, long initial) {
    method hash32 (line 796) | public static int hash32(long x, int initial) {

FILE: src/java/edu/stanford/math/plex/Chain.java
  class Chain (line 27) | public class Chain {
    method maxS (line 56) | public Simplex maxS() {
    method maxC (line 66) | public int maxC() {
    method Chain (line 71) | public Chain (int modulus, int[] cvec, Simplex[] elts) {
    method Chain (line 79) | public Chain (int modulus) {
    method Chain (line 85) | public Chain (int modulus, int coeff, Simplex elt) {
    method zero (line 96) | public static Chain zero(int modulus) {
    method isZero (line 102) | public static boolean isZero(Chain c) {
    method isZero (line 119) | public boolean isZero() {
    method mergeBasisElts (line 125) | protected Chain mergeBasisElts(Simplex[] first, int[] fc,
    method add (line 217) | public Chain add(Chain x, int c) {
    method normalize (line 226) | protected static Chain normalize(Simplex[] s, int[] c, int p) {
    method chain_sort (line 260) | protected static void chain_sort (Simplex[] b, int[] c) {
    method alternatingCoefficients (line 276) | protected static int[] alternatingCoefficients(int mod, int len) {
    method fromBoundary (line 296) | static Chain fromBoundary(Simplex[] boundary, int p) {
    method rewriteModP (line 310) | public int rewriteModP(int elt) {
    method toString (line 320) | public String toString() {
    method filter (line 348) | public Chain filter(SimplexTable simplexList) {
    method filter (line 377) | public Chain filter(List<Simplex> simplexList) {
    method coefficientOf (line 407) | public int coefficientOf(Simplex s) {
    method boundary (line 426) | Chain boundary(int p) {
    method ceq (line 465) | boolean ceq(Chain c) {
    method equals (line 483) | public boolean equals(Chain c) {
    method HashCode (line 493) | public int HashCode() {
    method random (line 503) | static Chain random(int p) {
    method s_and_c_okay (line 532) | static protected boolean s_and_c_okay (Simplex[] s, int[] c, int p) {

FILE: src/java/edu/stanford/math/plex/Cone.java
  class Cone (line 14) | public class Cone extends SimplexStream {
    method Cone (line 27) | public Cone(SimplexStream sstr) {
    method hasNext (line 36) | public boolean hasNext() {
    method next (line 43) | public Simplex next() {
    method size (line 75) | public int size() {
    method maxDimension (line 78) | public int maxDimension() {
    method iterator (line 82) | public Iterator<Simplex> iterator() {

FILE: src/java/edu/stanford/math/plex/DiscreteSpace.java
  class DiscreteSpace (line 9) | public class DiscreteSpace extends PointData {
    method count (line 20) | public int count() {
    method distance (line 33) | public double distance (int p1, int p2) {
    method DiscreteSpace (line 41) | public DiscreteSpace(int N) {

FILE: src/java/edu/stanford/math/plex/DistanceData.java
  class DistanceData (line 10) | public class DistanceData extends PointData {
    method count (line 22) | public int count() {
    method distance (line 38) | public double distance (int p1, int p2) {
    method DistanceData (line 48) | public DistanceData(double[][] data) {

FILE: src/java/edu/stanford/math/plex/EuclideanArrayData.java
  class EuclideanArrayData (line 17) | public class EuclideanArrayData extends PointData.NSpace {
    method dimension (line 29) | public int dimension() {
    method count (line 40) | public int count() {
    method distance (line 56) | public double distance (int p1, int p2) {
    method coordinate (line 85) | public double coordinate (int p, int i) {
    method get_pt (line 102) | public double[] get_pt (int p, double[] vec) {
    method pointsAreConsistent (line 111) | protected boolean pointsAreConsistent(double[] data, int dimension) {
    method pointsAreConsistent (line 127) | protected boolean pointsAreConsistent(double[][] data) {
    method EuclideanArrayData (line 151) | protected EuclideanArrayData() {
    method EuclideanArrayData (line 165) | public EuclideanArrayData(double[] data, int dimension) {
    method EuclideanArrayData (line 182) | public EuclideanArrayData(double[][] data) {
    method EuclideanArrayData (line 195) | public EuclideanArrayData(int num_pts, int dimension) {
    method EuclideanArrayData (line 210) | public EuclideanArrayData(int num_pts, int dimension, double min, doub...

FILE: src/java/edu/stanford/math/plex/ExplicitStream.java
  class ExplicitStream (line 41) | public class ExplicitStream extends SimplexStream {
    class DComplex (line 98) | public static class DComplex {
      method DComplex (line 114) | public DComplex(ExplicitStream parent, int dimension, int[][] C, dou...
      method parent_is_consistent (line 123) | protected boolean parent_is_consistent() {
      method hasNext (line 135) | public boolean hasNext() {
      method next (line 149) | public DComplex next() {
      method parent (line 163) | public ExplicitStream parent() {
      method dimension (line 173) | public int dimension() {
      method C (line 184) | public int[][] C() {
      method F (line 195) | public double[] F() {
    method dump (line 209) | public DComplex dump(int dim) {
    method hasNext (line 233) | public boolean hasNext() {
    method skip_to_next_index_pair (line 251) | protected void skip_to_next_index_pair() {
    method next (line 267) | public Simplex next() {
    method toDouble (line 276) | public static double[] toDouble(int[] in) {
    method toDouble (line 287) | public static double[][] toDouble(int[][] in) {
    method toInt (line 298) | public static int[] toInt(double[] in) {
    method toInt (line 309) | protected static int[][] toInt(double[][] in) {
    method ExplicitStream (line 325) | public ExplicitStream() {
    method open (line 340) | protected void open() {
    method makeExplicit (line 371) | public static ExplicitStream makeExplicit(SimplexStream str) {
    method remove (line 400) | public void remove(int[] vertices) {
    method prune (line 414) | public void prune(int[] vertices) {
    method remove (line 447) | public void remove(double[] vertices) {
    method prune (line 458) | public void prune(double[] vertices) {
    method remove (line 468) | public void remove(int[][] simplex_array) {
    method prune (line 480) | public void prune(int[][] simplex_array) {
    method remove (line 492) | public void remove(double[][] simplex_array) {
    method prune (line 502) | public void prune(double[][] simplex_array) {
    method add (line 507) | protected void add(Simplex s, double p) {
    method add (line 529) | public void add(int[] vertices, double parameter) {
    method add (line 543) | public void add(double[] vertices, double parameter) {
    method add (line 555) | public void add(int[][] simplex_array, double[] parray) {
    method add (line 573) | public void add(double[][] simplex_array, double[] parray) {
    method ensure_faces (line 580) | protected void ensure_faces(Simplex s, Double P, HashMap<Simplex,Doubl...
    method ensure_all_faces (line 607) | public void ensure_all_faces() {
    method ensure_length (line 625) | protected int[] ensure_length(int[] v, int index) {
    method message (line 635) | protected void message(String msg) {
    method faces_are_consistent (line 647) | protected boolean faces_are_consistent(Simplex s, Double P,
    method verify (line 704) | public boolean verify() {
    method verify (line 717) | public boolean verify(boolean verbose) {
    method close (line 739) | public void close() {
    method size (line 801) | public int size() {
    method maxDimension (line 825) | public int maxDimension() {
    method convert_filtration_index (line 846) | public double convert_filtration_index(int fi) {
    method iterator (line 858) | public Iterator<Simplex> iterator() {
    method iterator (line 871) | public Iterator<Simplex> iterator(int d) {
    class ExplicitStreamIterator (line 880) | protected static class ExplicitStreamIterator implements Iterator<Simp...
      method ExplicitStreamIterator (line 887) | protected ExplicitStreamIterator(ExplicitStream str) {
      method ExplicitStreamIterator (line 895) | protected ExplicitStreamIterator(ExplicitStream str, int dimension) {
      method skip_to_next_index_pair (line 910) | protected void skip_to_next_index_pair() {
      method parent_is_consistent (line 920) | protected boolean parent_is_consistent() {
      method has_next_index (line 930) | protected boolean has_next_index() {
      method hasNext (line 945) | public boolean hasNext() {
      method next (line 961) | public Simplex next() {
      method remove (line 979) | public void remove() {
    method enclose (line 992) | public static ExplicitStream enclose (Simplex[][] complex) {

FILE: src/java/edu/stanford/math/plex/LazyWitnessStream.java
  class LazyWitnessStream (line 29) | public class LazyWitnessStream extends SimplexStream {
    method hasNext (line 51) | public boolean hasNext() {
    method next (line 63) | public Simplex next() {
    method LazyWitnessStream (line 91) | LazyWitnessStream(double delta, int max_d, double R, int nu, int[] lan...
    method size (line 111) | public int size() {
    method maxDimension (line 123) | public int maxDimension() {
    method convert_filtration_index (line 138) | public double convert_filtration_index(int fi) {
    method iterator (line 153) | public Iterator<Simplex> iterator() {
    method LazyWitnessStream (line 158) | protected LazyWitnessStream() {
    method find_simplices (line 173) | protected SimplexStream.Stack find_simplices(double delta, double R_ma...

FILE: src/java/edu/stanford/math/plex/MappedBufferData.java
  class MappedBufferData (line 19) | public class MappedBufferData extends PointData.NSpace {
    method dimension (line 34) | public int dimension() {
    method start (line 45) | public int start() {
    method stop (line 56) | public int stop() {
    method count (line 67) | public int count() {
    method distance (line 83) | public double distance (int p1, int p2) {
    method get_pt (line 111) | public double[] get_pt (int p, double[] vec) {
    method set_pt (line 129) | public double[] set_pt (int p, double[] vec) {
    method coordinate (line 147) | public double coordinate (int p, int i) {
    method set_coordinate (line 165) | public double set_coordinate (int p, int i, double v) {
    method force (line 182) | public void force () {
    method MappedBufferData (line 189) | protected MappedBufferData() {
    method file_exists (line 199) | protected static boolean file_exists(String filename, boolean andWrite...
    method delete (line 212) | public static void delete(String filename) {
    method make_empty_file (line 220) | protected static void make_empty_file(String filename, int bytes) {
    method empty_dbl_file (line 242) | protected static MappedByteBuffer empty_dbl_file(String filename, int ...
    method map_file (line 251) | protected static MappedByteBuffer map_file(String filename, boolean wr...
    method buf_is_consistent (line 269) | protected boolean buf_is_consistent(DoubleBuffer buf, int dimension,
    method MappedBufferData (line 287) | public MappedBufferData(String filename, int length, int dimension,
    method MappedBufferData (line 309) | public MappedBufferData(String filename, int start_dimension,
    method MappedBufferData (line 341) | public MappedBufferData(String filename) {
    method MappedBufferData (line 346) | public MappedBufferData(String filename, boolean writable) {
    method MappedBufferData (line 351) | public MappedBufferData(String filename, int start_dimension) {
    method MappedBufferData (line 356) | public MappedBufferData(String filename, int num_pts, int dimension,
    method MappedBufferData (line 377) | public MappedBufferData(String filename, int num_pts,

FILE: src/java/edu/stanford/math/plex/Packed2Simplex.java
  class Packed2Simplex (line 13) | public class Packed2Simplex extends Simplex {
    method checkConstants (line 23) | static boolean checkConstants() {
    method v1 (line 30) | protected int v1() {
    method v2 (line 35) | protected int v2() {
    method Packed2Simplex (line 41) | protected Packed2Simplex() {
    method Packed2Simplex (line 46) | protected Packed2Simplex(long bits) {
    method check_2_vertices (line 50) | protected static boolean check_2_vertices(int[] v) {
    method assert_2_vertices (line 61) | protected static void assert_2_vertices(int[] v) {
    method Packed2Simplex (line 72) | protected Packed2Simplex(int v1) {
    method Packed2Simplex (line 76) | Packed2Simplex(int v1, int v2) {
    method hashCode (line 88) | public int hashCode() {
    method equals (line 101) | public boolean equals(Object obj) {
    method compareTo (line 109) | protected int compareTo(Packed2Simplex s) {
    method compareTo (line 126) | public int compareTo(Simplex s) {
    method slt (line 142) | boolean slt(Simplex s) {
    method seq (line 160) | boolean seq(Simplex s) {
    method copy (line 175) | public Simplex copy() {
    method dimension (line 188) | public int dimension() {
    method vertices (line 206) | public int[] vertices() {
    method vertices (line 234) | public int[] vertices(int[] verts) {
    method makeSimplex (line 250) | public static Simplex makeSimplex(int[] vertices) {
    method makeSimplexPresorted (line 263) | public static Simplex makeSimplexPresorted(int[] vertices) {
    method makeEdge (line 275) | public static Simplex makeEdge(int v1, int v2) {
    method makePoint (line 287) | public static Simplex makePoint(int v) {
    method boundaryArray (line 305) | public Simplex[] boundaryArray() {

FILE: src/java/edu/stanford/math/plex/Packed4Simplex.java
  class Packed4Simplex (line 13) | public class Packed4Simplex extends Simplex {
    method checkConstants (line 24) | static boolean checkConstants() {
    method v1 (line 31) | protected int v1() {
    method v2 (line 36) | protected int v2() {
    method v3 (line 41) | protected int v3() {
    method v4 (line 46) | protected int v4() {
    method Packed4Simplex (line 52) | protected Packed4Simplex() {
    method Packed4Simplex (line 58) | protected Packed4Simplex(long bits_lo, long bits_hi) {
    method check_4_vertices (line 63) | protected static boolean check_4_vertices(int[] v) {
    method assert_4_vertices (line 75) | protected static void assert_4_vertices(int[] v) {
    method Packed4Simplex (line 86) | protected Packed4Simplex(int v1, int v2, int v3) {
    method Packed4Simplex (line 92) | Packed4Simplex(int v1, int v2, int v3, int v4) {
    method hashCode (line 106) | public int hashCode() {
    method equals (line 119) | public boolean equals(Object obj) {
    method compareTo (line 127) | protected int compareTo(Packed4Simplex s) {
    method compareTo (line 148) | public int compareTo(Simplex s) {
    method slt (line 164) | boolean slt(Simplex s) {
    method seq (line 187) | boolean seq(Simplex s) {
    method copy (line 202) | public Simplex copy() {
    method dimension (line 215) | public int dimension() {
    method vertices (line 231) | public int[] vertices() {
    method vertices (line 258) | public int[] vertices(int[] verts) {
    method makeSimplex (line 274) | public static Simplex makeSimplex(int[] vertices) {
    method makeSimplexPresorted (line 285) | public static Simplex makeSimplexPresorted(int[] vertices) {
    method boundaryArray (line 304) | public Simplex[] boundaryArray() {

FILE: src/java/edu/stanford/math/plex/Packed6Simplex.java
  class Packed6Simplex (line 13) | public class Packed6Simplex extends Simplex {
    method checkConstants (line 25) | static boolean checkConstants() {
    method check_6_vertices (line 31) | protected static boolean check_6_vertices(int[] v) {
    method assert_6_vertices (line 44) | protected static void assert_6_vertices(int[] v) {
    method p6_v_to_l_lo (line 54) | protected static long p6_v_to_l_lo(int[] vertices) {
    method p6_v_to_l_mid (line 60) | protected static long p6_v_to_l_mid(int[] vertices) {
    method p6_v_to_l_hi (line 66) | protected static long p6_v_to_l_hi(int[] vertices) {
    method v6 (line 74) | protected int v6() {
    method v5 (line 79) | protected int v5() {
    method v4 (line 84) | protected int v4() {
    method v3 (line 89) | protected int v3() {
    method v2 (line 94) | protected int v2() {
    method v1 (line 99) | protected int v1() {
    method Packed6Simplex (line 106) | protected Packed6Simplex() {
    method Packed6Simplex (line 113) | protected Packed6Simplex(long bits_lo_val, long bits_mid_val, long bit...
    method Packed6Simplex (line 121) | Packed6Simplex(int v1, int v2, int v3, int v4, int v5) {
    method Packed6Simplex (line 127) | Packed6Simplex(int v1, int v2, int v3, int v4, int v5, int v6) {
    method hashCode (line 143) | public int hashCode() {
    method equals (line 156) | public boolean equals(Object obj) {
    method compareTo (line 164) | protected int compareTo(Packed6Simplex s) {
    method compareTo (line 189) | public int compareTo(Simplex s) {
    method slt (line 205) | boolean slt(Simplex s) {
    method seq (line 231) | boolean seq(Simplex s) {
    method copy (line 246) | public Simplex copy() {
    method dimension (line 259) | public int dimension() {
    method vertices (line 275) | public int[] vertices() {
    method vertices (line 305) | public int[] vertices(int[] verts) {
    method makeSimplex (line 324) | public static Simplex makeSimplex(int[] vertices) {
    method makeSimplexPresorted (line 333) | public static Simplex makeSimplexPresorted(int[] vertices) {
    method boundaryArray (line 350) | public Simplex[] boundaryArray() {

FILE: src/java/edu/stanford/math/plex/Packed8Simplex.java
  class Packed8Simplex (line 13) | public class Packed8Simplex extends Simplex {
    method checkConstants (line 26) | static boolean checkConstants() {
    method check_8_vertices (line 32) | protected static boolean check_8_vertices(int[] v) {
    method assert_8_vertices (line 46) | protected static void assert_8_vertices(int[] v) {
    method p8_v_to_l_lo (line 56) | protected static long p8_v_to_l_lo(int[] vertices) {
    method p8_v_to_l_lo_mid (line 62) | protected static long p8_v_to_l_lo_mid(int[] vertices) {
    method p8_v_to_l_hi_mid (line 68) | protected static long p8_v_to_l_hi_mid(int[] vertices) {
    method p8_v_to_l_hi (line 74) | protected static long p8_v_to_l_hi(int[] vertices) {
    method v8 (line 82) | protected int v8() {
    method v7 (line 87) | protected int v7() {
    method v6 (line 92) | protected int v6() {
    method v5 (line 97) | protected int v5() {
    method v4 (line 102) | protected int v4() {
    method v3 (line 107) | protected int v3() {
    method v2 (line 112) | protected int v2() {
    method v1 (line 117) | protected int v1() {
    method Packed8Simplex (line 124) | protected Packed8Simplex() {
    method Packed8Simplex (line 132) | protected Packed8Simplex(long bits_lo_val, long bits_lo_mid_val,
    method Packed8Simplex (line 142) | protected Packed8Simplex(int v1, int v2, int v3, int v4, int v5, int v6,
    method Packed8Simplex (line 151) | protected Packed8Simplex(int v1, int v2, int v3, int v4, int v5, int v6,
    method hashCode (line 169) | public int hashCode() {
    method equals (line 185) | public boolean equals(Object obj) {
    method compareTo (line 194) | protected int compareTo(Packed8Simplex s) {
    method compareTo (line 223) | public int compareTo(Simplex s) {
    method slt (line 242) | boolean slt(Simplex s) {
    method seq (line 275) | boolean seq(Simplex s) {
    method copy (line 291) | public Simplex copy() {
    method dimension (line 304) | public int dimension() {
    method vertices (line 320) | public int[] vertices() {
    method vertices (line 353) | public int[] vertices(int[] verts) {
    method makeSimplex (line 374) | public static Simplex makeSimplex(int[] vertices) {
    method makeSimplexPresorted (line 384) | public static Simplex makeSimplexPresorted(int[] vertices) {
    method boundaryArray (line 402) | public Simplex[] boundaryArray() {

FILE: src/java/edu/stanford/math/plex/Persistence.java
  class Persistence (line 25) | public class Persistence {
    method baseModulus (line 38) | public static int baseModulus() {
    method setBaseModulus (line 47) | public static void setBaseModulus(int modulus) {
    method multiplicative_inverses (line 55) | private static int[] multiplicative_inverses(int p) {
    method removePivotRows (line 80) | private Chain removePivotRows(Simplex sigma) {
    method cycleSpaceDimension (line 128) | public int cycleSpaceDimension() {
    method computeIntervals (line 140) | public PersistenceInterval.Float[] computeIntervals(SimplexStream stre...
    method computeIntervals (line 154) | public PersistenceInterval.Float[] computeIntervals(SimplexStream stream,
    method computeRawIntervals (line 178) | public PersistenceInterval[] computeRawIntervals (SimplexStream stream,

FILE: src/java/edu/stanford/math/plex/PersistenceBasis.java
  class PersistenceBasis (line 17) | public class PersistenceBasis {
    method baseModulus (line 25) | public static int baseModulus() {
    method setBaseModulus (line 34) | public static void setBaseModulus(int modulus) {
    method multiplicative_inverses (line 42) | protected static int[] multiplicative_inverses(int p) {
    method boundaryMatrix (line 69) | public static double[][] boundaryMatrix(SimplexStream stream, double f...
    method boundaryMatrixSparse (line 115) | public static double[][] boundaryMatrixSparse(SimplexStream stream, do...
    method chainVector (line 170) | public static double[] chainVector(SimplexStream stream, Chain chain, ...
    method basis (line 193) | public static int[][] basis(SimplexStream stream, int degree, double f...
    method computeIntervals (line 226) | public static PersistenceBasisInterval.Float[]
    method computeIntervals (line 247) | public static PersistenceBasisInterval.Float[]
    method computeIntervals (line 271) | public PersistenceBasisInterval.Float[]
    type SimplexType (line 291) | protected enum SimplexType {
    method computeRawIntervals (line 294) | public PersistenceBasisInterval[]
    class ListItem (line 421) | protected static class ListItem {
    method computePersistentCohomologyZigZag (line 436) | public static PersistenceBasisInterval[] computePersistentCohomologyZi...
    method computePersistentCohomologyZigZag (line 562) | public static PersistenceBasisInterval[] computePersistentCohomologyZi...

FILE: src/java/edu/stanford/math/plex/PersistenceBasisInterval.java
  class PersistenceBasisInterval (line 11) | abstract public class PersistenceBasisInterval
    method infiniteExtent (line 26) | public abstract boolean infiniteExtent();
    method toDouble (line 34) | public abstract double[] toDouble();
    method basis (line 42) | public abstract Chain basis();
    method toPersistenceInterval (line 50) | public abstract PersistenceInterval toPersistenceInterval();
    method PersistenceBasisInterval (line 53) | protected PersistenceBasisInterval(int d) {
    method toString (line 64) | public String toString() {
    class Int (line 74) | public static class Int extends PersistenceBasisInterval {
      method Int (line 82) | protected Int() { super(0); start = 0; end = 0; basisElement = null; }
      method Int (line 84) | public Int(Chain basisElement, int start, int end) {
      method Int (line 92) | public Int(Chain basisElement, int start) {
      method infiniteExtent (line 106) | public boolean infiniteExtent() {
      method toString (line 116) | public String toString() {
      method toPersistenceInterval (line 125) | public PersistenceInterval toPersistenceInterval() {
      method toDouble (line 136) | public double[] toDouble() {
      method basis (line 149) | public Chain basis() {
      method hashCode (line 160) | public int hashCode() {
      method equals (line 175) | public boolean equals(Object obj) {
      method compareTo (line 193) | public int compareTo(PersistenceBasisInterval p) {
    class Float (line 206) | public static class Float extends PersistenceBasisInterval {
      method Float (line 214) | protected Float() { super(0); start = 0; end = 0; basisElement = nul...
      method Float (line 216) | public Float(Chain basisElement, double start, double end) {
      method Float (line 224) | public Float(Chain basisElement, double start) {
      method infiniteExtent (line 238) | public boolean infiniteExtent() {
      method toString (line 248) | public String toString() {
      method toPersistenceInterval (line 257) | public PersistenceInterval toPersistenceInterval() {
      method toDouble (line 268) | public double[] toDouble() {
      method basis (line 281) | public Chain basis() {
      method hashCode (line 292) | public int hashCode() {
      method equals (line 307) | public boolean equals(Object obj) {
      method compareTo (line 325) | public int compareTo(PersistenceBasisInterval p) {

FILE: src/java/edu/stanford/math/plex/PersistenceInterval.java
  class PersistenceInterval (line 11) | abstract public class PersistenceInterval implements Comparable<Persiste...
    method infiniteExtent (line 25) | public abstract boolean infiniteExtent();
    method toDouble (line 33) | public abstract double[] toDouble();
    method PersistenceInterval (line 36) | private PersistenceInterval(int d) {
    method toString (line 47) | public String toString() {
    class Int (line 57) | public static class Int extends PersistenceInterval {
      method Int (line 66) | public Int(int dimension, int start, int end) {
      method Int (line 73) | public Int(int dimension, int start) {
      method infiniteExtent (line 86) | public boolean infiniteExtent() {
      method toString (line 96) | public String toString() {
      method toDouble (line 109) | public double[] toDouble() {
      method hashCode (line 123) | public int hashCode() {
      method equals (line 138) | public boolean equals(Object obj) {
      method compareTo (line 155) | public int compareTo(PersistenceInterval p) {
    class Float (line 168) | public static class Float extends PersistenceInterval {
      method Float (line 177) | public Float(int dimension, double start, double end) {
      method Float (line 184) | public Float(int dimension, double start) {
      method infiniteExtent (line 197) | public boolean infiniteExtent() {
      method toString (line 207) | public String toString() {
      method toDouble (line 220) | public double[] toDouble() {
      method hashCode (line 234) | public int hashCode() {
      method equals (line 249) | public boolean equals(Object obj) {
      method compareTo (line 266) | public int compareTo(PersistenceInterval p) {

FILE: src/java/edu/stanford/math/plex/Plex.java
  class Plex (line 26) | public class Plex {
    method intersection_count (line 34) | public static int intersection_count(int[] v1, int[] v2) {
    method sorted_intersection_count (line 74) | public static int sorted_intersection_count(int[] v1, int[] v2) {
    method random_subset (line 131) | public static void random_subset(int[] set, int set_size,
    method random_subset (line 160) | public static void random_subset(int[] set, int[] subset) {
    method random_subset (line 172) | public static void random_subset(int N, int[] subset, int subset_size) {
    method random_subset (line 193) | public static void random_subset(int N, int[] subset) {
    method is_permutation (line 198) | protected static boolean is_permutation (int[] perm) {
    method random_permutation (line 215) | public static void random_permutation(int[] perm) {
    method toString (line 238) | public static String toString(int[] x, int max_entries) {
    method toString (line 259) | public static String toString(int[] x) {
    method toString (line 270) | public static String toString(byte[] x, int max_entries) {
    method toString (line 291) | public static String toString(byte[] x) {
    method toString (line 302) | public static String toString(int[][] x, int max_entries) {
    method toString (line 322) | public static String toString(int[][] x) {
    method toString (line 333) | public static String toString(double[] x, int max_entries) {
    method toString (line 354) | public static String toString(double[] x) {
    method toString (line 366) | public static String toString(double[][] x, int max_entries) {
    method toString (line 387) | public static String toString(double[][] x) {
    method toString (line 400) | public static String toString(long[] x, int max_entries) {
    method toString (line 417) | public static String toString(long[] x) {
    method random_index_subset (line 430) | public static void random_index_subset(int N, int[] subset, int subset...
    method comparePtArrays (line 458) | static int comparePtArrays (int[] pts1, int[] pts2) {
    method equalPtArrays (line 470) | static boolean equalPtArrays (int[] pts1, int[] pts2) {
    method firstSmallerPtIndex (line 488) | protected static int firstSmallerPtIndex (int arg, int lo, int[] pts) {
    method ptArrayIsSubset (line 520) | protected static boolean ptArrayIsSubset (int[] ipts, int[] jpts) {
    class BettiNumbers (line 546) | public static class BettiNumbers {
      method init_okay (line 550) | static protected boolean init_okay(int[] init) {
      method BettiNumbers (line 561) | protected BettiNumbers() { numbers = null; }
      method BettiNumbers (line 570) | public BettiNumbers(int[] init) {
      method toString (line 584) | public String toString() {
      method equals (line 600) | public boolean equals(Object obj) {
    method FilterInfinite (line 615) | public static BettiNumbers FilterInfinite(PersistenceInterval[] coll) {
    method FilterInfinite (line 636) | public static BettiNumbers FilterInfinite(PersistenceBasisInterval[] c...
    method SimplexStack (line 662) | public static SimplexStream.Stack SimplexStack(int max_findex, int max...
    method Persistence (line 675) | public static Persistence Persistence () {
    method PersistenceBasis (line 688) | public static PersistenceBasis PersistenceBasis () {
    method EuclideanArrayData (line 703) | public static EuclideanArrayData  EuclideanArrayData(int num_pts, int ...
    method EuclideanArrayData (line 717) | public static EuclideanArrayData EuclideanArrayData(double[] data, int...
    method EuclideanArrayData (line 730) | public static EuclideanArrayData EuclideanArrayData(double[][] data) {
    method EuclideanArrayData (line 744) | public static EuclideanArrayData EuclideanArrayData(String filename) {
    method readMatrix (line 756) | public static double[][] readMatrix(Reader input) {
    method readMatrix (line 816) | public static double[][] readMatrix(String inputFilename) {
    method d_okay (line 838) | protected static boolean d_okay(double[][] d) {
    method DistanceData (line 855) | public static DistanceData  DistanceData(double[][] d) {
    method Torus (line 868) | public static Torus Torus (int n, int d) {
    method RipsStream (line 882) | public static RipsStream RipsStream(double delta, int max_d,
    method ExplicitStream (line 893) | public static ExplicitStream ExplicitStream() {
    method makeExplicit (line 905) | public static ExplicitStream makeExplicit(SimplexStream str) {
    method SimplexTable (line 921) | public static SimplexTable SimplexTable (int limit) {
    method WitnessStream (line 938) | public static WitnessStream WitnessStream(double delta, int max_d, dou...
    method LazyWitnessStream (line 958) | public static LazyWitnessStream LazyWitnessStream(double delta, int ma...
    method filter_pintervals (line 965) | protected static PersistenceInterval.Float[] filter_pintervals
    method equalPersistenceIntervals (line 994) | public static boolean equalPersistenceIntervals(PersistenceInterval.Fl...
    method normalizeUpperBound (line 1017) | protected static double normalizeUpperBound(double arg) {
    method printable_intervals (line 1041) | protected static double[][][] printable_intervals(PersistenceInterval[...
    method plot (line 1093) | public static void plot(PersistenceInterval[] arg, String label, doubl...
    method plot (line 1113) | public static void plot(PersistenceBasisInterval[] arg,
    method scatter (line 1132) | public static void scatter(PersistenceInterval[] arg, String label, do...
    method scatter (line 1152) | public static void scatter(PersistenceBasisInterval[] arg,
    method useMessageWindow (line 1169) | public static void useMessageWindow(boolean flag) {
    method useMessageWindow (line 1179) | public static boolean useMessageWindow() {
    method messageWindow (line 1190) | public static PlexMessageWindow messageWindow(String title) {
    method main (line 1205) | public static void main(String[] args) {

FILE: src/java/edu/stanford/math/plex/PlexMessageWindow.java
  class PlexMessageWindow (line 20) | public class PlexMessageWindow {
    method PlexMessageWindow (line 34) | public PlexMessageWindow(String title) {
    method message (line 56) | public void message(String messageString) {

FILE: src/java/edu/stanford/math/plex/PlexSort.java
  class PlexSort (line 9) | public class PlexSort {
    class Comp (line 25) | public static abstract class Comp {
      method fn (line 36) | public abstract int fn(int i, int j);
    class CompL (line 39) | public static abstract class CompL {
      method fn (line 50) | public abstract int fn(long i, long j);
    class CompObj (line 53) | public static abstract class CompObj {
      method fn (line 64) | public abstract int fn(Object o1 , Object o2);
    method swap (line 68) | private static void swap(int[] x, int i, int j) {
    method med3 (line 75) | private static int med3(int[] x, int a, int b, int c, Comp comp) {
    method swapfunc (line 85) | private static void swapfunc(int[] x, int i, int j, int len) {
    method swap (line 97) | private static void swap(long[] x, int i, int j) {
    method med3 (line 104) | private static int med3(long[] x, int a, int b, int c, CompL comp) {
    method swapfunc (line 114) | private static void swapfunc(long[] x, int i, int j, int len) {
    method swap (line 126) | private static void swap(Object[] x, int i, int j) {
    method med3 (line 133) | private static int med3(Object[] x, int a, int b, int c, CompObj comp) {
    method swapfunc (line 143) | private static void swapfunc(Object[] x, int i, int j, int len) {
    method comp_sort (line 172) | public static void comp_sort(int[] x, int start, int len, Comp comp) {
    method comp_sort (line 245) | public static void comp_sort(long[] x, int start, int len, CompL comp) {
    method comp_sort (line 318) | public static void comp_sort(Object[] x, int start, int len, CompObj c...
    method sort (line 398) | public static void sort(int[] indices, int start, int end,
    method sort (line 417) | public static void sort(int[] indices, int start, int end,
    method sort (line 446) | public static void sort(int[] indices, final int[] vals, boolean rever...
    method sort (line 450) | public static void sort(int[] indices, final int[] vals) {
    method reverse_sort (line 454) | public static void reverse_sort(int[] indices, final int[] vals) {
    method sort (line 458) | public static void sort(int[] indices, final double[] vals, boolean re...
    method sort (line 462) | public static void sort(int[] indices, final double[] vals) {
    method reverse_sort (line 466) | public static void reverse_sort(int[] indices, final double[] vals) {

FILE: src/java/edu/stanford/math/plex/PointData.java
  class PointData (line 12) | public abstract class PointData {
    method distance (line 25) | abstract public double distance(int p1, int p2);
    method count (line 38) | abstract public int count();
    method good_enough_point (line 51) | boolean good_enough_point (int pt, int[] other_pts, int other_pts_coun...
    method random_points (line 66) | public int[] random_points(int number_of_points) {
    class NSpace (line 102) | public abstract static class NSpace extends PointData {
      method dimension (line 109) | abstract public int dimension();
      method coordinate (line 110) | abstract public double coordinate(int p, int i);
      method xi (line 111) | public double xi(int p, int i) {
    class Discrete (line 116) | public static class Discrete extends PointData {
      class DSS (line 119) | protected static class DSS extends SimplexStream {
        method hasNext (line 124) | public boolean hasNext() {
        method next (line 128) | public Simplex next() {
        method size (line 132) | public int size() {
        method maxDimension (line 136) | public int maxDimension() {
        method iterator (line 148) | public Iterator<Simplex> iterator() {
        method DSS (line 152) | protected DSS() {
        method DSS (line 157) | public DSS(SimplexStream s, int n, int max_d) {
      method distance (line 173) | public double distance(int p1, int p2) {
      method count (line 191) | public int count() {
      method Discrete (line 195) | protected Discrete() {
      method Discrete (line 205) | public Discrete(int n) {
      method DSphere (line 215) | public static SimplexStream DSphere(int d) {
      method DSphereKskeleton (line 223) | public static SimplexStream DSphereKskeleton(int d, int k) {
    class Predicate (line 235) | public static abstract class Predicate {
      method data (line 244) | abstract public PointData data();
      method use (line 255) | abstract public boolean use(int i);

FILE: src/java/edu/stanford/math/plex/RDirectBufferData.java
  class RDirectBufferData (line 13) | public class RDirectBufferData extends PointData {
    method RDirectBufferData (line 34) | public RDirectBufferData(int count, ByteBuffer buf) {
    method distance (line 54) | public double distance(int p1, int p2) {
    method count (line 60) | public int count() {

FILE: src/java/edu/stanford/math/plex/RipsStream.java
  class RipsStream (line 20) | public class RipsStream extends SimplexStream {
    method hasNext (line 74) | public boolean hasNext() {
    method next (line 85) | public Simplex next() {
    method RipsStream (line 101) | RipsStream(double delta, int max_d, double max_length, PointData data) {
    method size (line 117) | public int size() {
    method maxDimension (line 128) | public int maxDimension() {
    method convert_filtration_index (line 141) | public double convert_filtration_index(int fi) {
    method iterator (line 157) | public Iterator<Simplex> iterator() {
    method iterator (line 170) | public Iterator<Simplex> iterator(int d) {
    method matchingSimplices (line 183) | public Simplex[] matchingSimplices(int dimension, int test_index,
    method matchingSimplices (line 231) | public Simplex[] matchingSimplices(int dimension, double test_len,
    method RipsStream (line 264) | protected RipsStream() {
    method edge_index (line 277) | static int edge_index(int i, int j, int n) {
    method check_edge_index (line 283) | static boolean check_edge_index(int n) {
    method all_edges_present (line 304) | static int all_edges_present(int[] verts,
    method find_simplices (line 341) | protected SimplexStream.Stack find_simplices(double max_dist,

FILE: src/java/edu/stanford/math/plex/Simplex.java
  class Simplex (line 56) | abstract public class Simplex implements Comparable<Simplex> {
    method setfindex (line 81) | public int setfindex (int i) {
    method decrement_findex (line 97) | public int decrement_findex () {
    method setChain (line 114) | public Chain setChain (Chain c) {
    method clearChain (line 128) | public void clearChain () {
    method findex (line 140) | public int findex () {
    method chain (line 152) | public Chain chain () {
    method dimension (line 164) | abstract public int dimension();
    method copy (line 174) | abstract public Simplex copy();
    method vertices (line 184) | abstract public int[] vertices();
    method vertices (line 196) | abstract public int[] vertices(int verts[]);
    method subset (line 208) | public boolean subset(Simplex s) {
    method subset (line 229) | public boolean subset(Simplex s, int[] v, int[] sv) {
    method hashCode (line 258) | public int hashCode() {
    method equals (line 273) | public boolean equals(Object obj) {
    method compareTo (line 295) | public int compareTo(Simplex s) {
    method slt (line 334) | abstract boolean slt(Simplex s);
    method seq (line 344) | abstract boolean seq(Simplex s);
    method getSimplex (line 354) | public static Simplex getSimplex (int[] vertices) {
    method getSimplex (line 377) | public static Simplex getSimplex (int[] vertices, int findex) {
    method getSimplexPresorted (line 390) | public static Simplex getSimplexPresorted (int[] vertices) {
    method getSimplexPresorted (line 414) | public static Simplex getSimplexPresorted(int[] vertices, int findex) {
    method makeEdge (line 428) | public static Simplex makeEdge (int v1, int v2, int findex) {
    method makePoint (line 441) | public static Simplex makePoint (int v, int findex) {
    method addVertex (line 455) | public Simplex addVertex(int v) {
    method addVertex (line 472) | public Simplex addVertex (int v, int f) {
    method toString (line 485) | public String toString() {
    method vertex_sort (line 510) | public static int[] vertex_sort (int[] vertices) {
    method dist_sort (line 536) | public static double[] dist_sort (double[] distances) {
    method simplex_reverse_sort (line 562) | public static int[] simplex_reverse_sort (int[] vertices) {
    method persistence_sort (line 584) | public static void persistence_sort(Simplex[] sarray) {
    method boundaryArray (line 615) | abstract public Simplex[] boundaryArray();
    method boundary (line 624) | public Chain boundary(int p) {
    method random (line 650) | static Simplex random() {

FILE: src/java/edu/stanford/math/plex/SimplexFaceIterator.java
  class SimplexFaceIterator (line 14) | public class SimplexFaceIterator {
    method hasNext (line 32) | public boolean hasNext() {
    method next (line 77) | public int[] next () {
    method SimplexFaceIterator (line 98) | protected SimplexFaceIterator() {
    method SimplexFaceIterator (line 118) | public SimplexFaceIterator(int[] vertices, int dimension) {
    method SimplexFaceIterator (line 155) | public SimplexFaceIterator(Simplex s, int dimension) {
    method getDimension (line 162) | public int getDimension() {
    method getSignOfLast (line 169) | public int getSignOfLast() {

FILE: src/java/edu/stanford/math/plex/SimplexStream.java
  class SimplexStream (line 25) | public abstract class SimplexStream
    method hasNext (line 35) | public abstract boolean hasNext();
    method next (line 44) | public abstract Simplex next();
    method remove (line 51) | public void remove() {
    method size (line 62) | public abstract int size();
    method maxDimension (line 71) | public abstract int maxDimension();
    method convertInterval (line 81) | public PersistenceInterval.Float convertInterval(PersistenceInterval p) {
    method convertInterval (line 101) | public PersistenceBasisInterval.Float convertInterval(PersistenceBasis...
    method convert_filtration_index (line 124) | public double convert_filtration_index(int fi) {
    method verify (line 136) | public boolean verify() {
    type ComparisonType (line 152) | public enum ComparisonType { LT, LE, EQ, GE, GT }
    class Tail (line 167) | public static class Tail {
      method Tail (line 175) | public Tail() {
      method Tail (line 182) | public Tail(int len) {
      method toString (line 188) | public String toString() {
      method enqueue (line 195) | public Tail enqueue(Simplex s) {
    class Head (line 214) | public static class Head {
      method Head (line 221) | protected Head() {
      method Head (line 225) | public Head(Tail q) {
      method copy (line 233) | public Head copy() {
      method toString (line 241) | public String toString() {
      method nextEntry (line 257) | public Simplex nextEntry() {
      method lessThan (line 278) | public boolean lessThan (Head q) {
      method eql (line 292) | public boolean eql(Head q) {
    class Stack (line 311) | public static class Stack extends SimplexStream {
      class Segment (line 315) | protected static class Segment {
        method Segment (line 321) | protected Segment() {
        method Segment (line 328) | protected Segment(int len) {
        method toString (line 334) | public String toString() {
        method push (line 341) | protected Segment push(Simplex s) {
      method Stack (line 366) | protected Stack() {
      method Stack (line 386) | public Stack(int max_findex, int max_d) {
      method toString (line 396) | public String toString() {
      method simplexIndex (line 403) | protected int simplexIndex(Simplex s) {
      method push (line 418) | public Simplex push(Simplex s) {
      method size (line 434) | public int size() {
      method maxDimension (line 445) | public int maxDimension() {
      method hasNext (line 456) | public boolean hasNext() {
      method next (line 495) | public Simplex next() {
      class StackIterator (line 544) | protected static class StackIterator implements Iterator<Simplex> {
        method StackIterator (line 552) | protected StackIterator() {
        method StackIterator (line 561) | public StackIterator(Stack stack) {
        method StackIterator (line 570) | public StackIterator(Stack stack, int dimension) {
        method hasNext (line 589) | public boolean hasNext() {
        method next (line 631) | public Simplex next() {
        method remove (line 669) | public void remove() {
      method iterator (line 682) | public Iterator<Simplex> iterator() {
      method iterator (line 695) | public Iterator<Simplex> iterator(int d) {

FILE: src/java/edu/stanford/math/plex/SimplexTable.java
  class SimplexTable (line 16) | public class SimplexTable implements Iterable<Simplex> {
    method SimplexTable (line 31) | protected SimplexTable() {}
    method SimplexTable (line 55) | public SimplexTable(int limit) {
    method grow_table (line 74) | protected void grow_table(int newLimit) {
    method size (line 102) | public int size() {
    method limit (line 111) | public int limit() {
    method get (line 127) | public Simplex get(Simplex s) {
    method put (line 164) | public Simplex put(Simplex s) {
    method getInterned (line 202) | public Simplex getInterned(Simplex s) {
    method iterator (line 236) | public Iterator<Simplex> iterator() {
    class SimpleTableIterator (line 245) | protected static class SimpleTableIterator implements Iterator<Simplex> {
      method SimpleTableIterator (line 252) | protected SimpleTableIterator(SimplexTable tbl) {
      method parent_is_consistent (line 261) | protected boolean parent_is_consistent() {
      method hasNext (line 271) | public boolean hasNext() {
      method next (line 287) | public Simplex next() {
      method remove (line 306) | public void remove() {

FILE: src/java/edu/stanford/math/plex/TmpStream.java
  class TmpStream (line 14) | public class TmpStream extends SimplexStream implements Iterable<Simplex...
    method PaperComplex (line 24) | static Simplex[] PaperComplex() {
    method TorusComplex (line 49) | private static Simplex[] TorusComplex() {
    method TmpStream (line 126) | public TmpStream(Simplex[] entries) {
    method hasNext (line 148) | public boolean hasNext() {
    method next (line 161) | public Simplex next() {
    method remove (line 173) | public void remove() {
    method size (line 177) | public int size() {
    method maxDimension (line 181) | public int maxDimension() {
    method iterator (line 185) | public Iterator<Simplex> iterator() {
    method PaperTestCase (line 189) | public static TmpStream PaperTestCase() {
    method Torus (line 192) | public static TmpStream Torus() {

FILE: src/java/edu/stanford/math/plex/Torus.java
  class Torus (line 16) | public class Torus extends PointData.NSpace {
    method dimension (line 30) | public int dimension() {
    method coordinate (line 42) | public double coordinate(int p, int i) {
    method count (line 61) | public int count() {
    method distance (line 77) | public double distance (int p1, int p2) {
    method pointsAreConsistent (line 99) | private boolean pointsAreConsistent(double[] data, int dimension) {
    method Torus (line 120) | public Torus(double[] data, int d) {
    method expt (line 127) | private int expt(int n, int k) {
    method incr_pt (line 145) | private boolean incr_pt(double[] pt, double incr) {
    method Torus (line 164) | public Torus(int n, int d) {
    method Torus (line 183) | public Torus() {

FILE: src/java/edu/stanford/math/plex/WitnessStream.java
  class WitnessStream (line 23) | public class WitnessStream extends SimplexStream {
    method makeRandomLandmarks (line 34) | public static int[] makeRandomLandmarks(PointData data, int L) {
    method estimateRmax (line 61) | public static double estimateRmax(PointData data, int[] landmarks) {
    method hasNext (line 95) | public boolean hasNext() {
    method next (line 106) | public Simplex next() {
    method WitnessStream (line 125) | WitnessStream(double delta, int max_d, double R,
    method size (line 143) | public int size() {
    method maxDimension (line 154) | public int maxDimension() {
    method convert_filtration_index (line 167) | public double convert_filtration_index(int fi) {
    method iterator (line 179) | public Iterator<Simplex> iterator() {
    method WitnessStream (line 184) | protected WitnessStream() {
    method m_index (line 214) | protected static int m_index(int n, int k, int N) {
    method distance_ln (line 225) | static double distance_ln(int l, int n, int[] landmarks, PointData dat...
    method D_index (line 237) | static int D_index(int l, int n, int L, int N) {
    method min (line 243) | static double min(double x, double y) {
    method max (line 250) | static double max(double x, double y) {
    method max (line 257) | static int max(int x, int y) {
    method find_simplices (line 298) | protected SimplexStream.Stack

FILE: src/java/edu/stanford/math/plex4/api/FilteredStreamInterface.java
  class FilteredStreamInterface (line 18) | public class FilteredStreamInterface {
    method createExplicitSimplexStream (line 19) | public static ExplicitSimplexStream createExplicitSimplexStream() {
    method createExplicitSimplexStream (line 23) | public static ExplicitSimplexStream createExplicitSimplexStream(double...
    method createExplicitCellStream (line 27) | public static ExplicitCellStream createExplicitCellStream() {
    method createExplicitCellStream (line 31) | public static ExplicitCellStream createExplicitCellStream(double maxFi...
    method createPlex4VietorisRipsStream (line 35) | public static VietorisRipsStream<double[]> createPlex4VietorisRipsStre...
    method createPlex4VietorisRipsStream (line 44) | public static <T> VietorisRipsStream<T> createPlex4VietorisRipsStream(...
    method createPlex4VietorisRipsStream (line 50) | public static VietorisRipsStream<double[]> createPlex4VietorisRipsStre...
    method createPlex4VietorisRipsStream (line 59) | public static <T> VietorisRipsStream<T> createPlex4VietorisRipsStream(...
    method createPlex3VietorisRipsStream (line 65) | public static AbstractFilteredStream<Simplex> createPlex3VietorisRipsS...
    method createPlex4LazyWitnessStream (line 75) | public static LazyWitnessStream<double[]> createPlex4LazyWitnessStream...
    method createPlex3LazyWitnessStream (line 81) | public static AbstractFilteredStream<Simplex> createPlex3LazyWitnessSt...
    method createPlex4WitnessStream (line 91) | public static WitnessStream<double[]> createPlex4WitnessStream(Landmar...
    method createPlex3WitnessStream (line 98) | public static AbstractFilteredStream<Simplex> createPlex3WitnessStream...
    method convertTo1Based (line 108) | private static int[] convertTo1Based(int[] array) {

FILE: src/java/edu/stanford/math/plex4/api/PersistenceAlgorithmInterface.java
  class PersistenceAlgorithmInterface (line 34) | public class PersistenceAlgorithmInterface {
    method getPlex3SimplicialAbsoluteHomology (line 43) | public static AbstractPersistenceAlgorithm<Simplex> getPlex3Simplicial...
    method getBooleanSimplicialAbsoluteHomology (line 47) | public static AbstractPersistenceBasisAlgorithm<Simplex, BooleanSparse...
    method getIntSimplicialAbsoluteHomology (line 51) | public static AbstractPersistenceBasisAlgorithm<Simplex, IntSparseForm...
    method getRationalSimplicialAbsoluteHomology (line 55) | public static AbstractPersistenceBasisAlgorithm<Simplex, ObjectSparseF...
    method getBooleanSimplicialClassicalHomology (line 59) | public static AbstractPersistenceAlgorithm<Simplex> getBooleanSimplici...
    method getIntSimplicialClassicalHomology (line 63) | public static AbstractPersistenceAlgorithm<Simplex> getIntSimplicialCl...
    method getRationalSimplicialClassicalHomology (line 67) | public static AbstractPersistenceAlgorithm<Simplex> getRationalSimplic...
    method getBooleanSimplicialRelativeHomology (line 71) | public static AbstractPersistenceBasisAlgorithm<Simplex, BooleanSparse...
    method getIntSimplicialRelativeHomology (line 75) | public static AbstractPersistenceBasisAlgorithm<Simplex, IntSparseForm...
    method getRationalSimplicialRelativeHomology (line 79) | public static AbstractPersistenceBasisAlgorithm<Simplex, ObjectSparseF...
    method getAllPlex4SimplicialAbsoluteHomologyAlgorithms (line 83) | public static List<AbstractPersistenceAlgorithm<Simplex>> getAllPlex4S...
    method getAllSimplicialAbsoluteHomologyAlgorithms (line 95) | public static List<AbstractPersistenceAlgorithm<Simplex>> getAllSimpli...
    method getBooleanCellularAbsoluteHomology (line 105) | public static AbstractPersistenceBasisAlgorithm<Cell, BooleanSparseFor...
    method getIntCellularAbsoluteHomology (line 109) | public static AbstractPersistenceBasisAlgorithm<Cell, IntSparseFormalS...
    method getRationalCellularAbsoluteHomology (line 113) | public static AbstractPersistenceBasisAlgorithm<Cell, ObjectSparseForm...
    method getBooleanCellularClassicalHomology (line 117) | public static AbstractPersistenceAlgorithm<Cell> getBooleanCellularCla...
    method getIntCellularClassicalHomology (line 121) | public static AbstractPersistenceAlgorithm<Cell> getIntCellularClassic...
    method getRationalCellularClassicalHomology (line 125) | public static AbstractPersistenceAlgorithm<Cell> getRationalCellularCl...
    method getBooleanCellularRelativeHomology (line 129) | public static AbstractPersistenceBasisAlgorithm<Cell, BooleanSparseFor...
    method getIntCellularRelativeHomology (line 133) | public static AbstractPersistenceBasisAlgorithm<Cell, IntSparseFormalS...
    method getRationalCellularRelativeHomology (line 137) | public static AbstractPersistenceBasisAlgorithm<Cell, ObjectSparseForm...
    method getAllCellularAbsoluteHomologyAlgorithms (line 141) | public static List<AbstractPersistenceAlgorithm<Cell>> getAllCellularA...
    method getBooleanSimplexPairAbsoluteHomology (line 157) | public static AbstractPersistenceBasisAlgorithm<SimplexPair, BooleanSp...
    method getIntSimplexPairAbsoluteHomology (line 161) | public static AbstractPersistenceBasisAlgorithm<SimplexPair, IntSparse...
    method getRationalSimplexPairAbsoluteHomology (line 165) | public static AbstractPersistenceBasisAlgorithm<SimplexPair, ObjectSpa...
    method getBooleanSimplexPairClassicalHomology (line 169) | public static AbstractPersistenceAlgorithm<SimplexPair> getBooleanSimp...
    method getIntSimplexPairClassicalHomology (line 173) | public static AbstractPersistenceAlgorithm<SimplexPair> getIntSimplexP...
    method getRationalSimplexPairClassicalHomology (line 177) | public static AbstractPersistenceAlgorithm<SimplexPair> getRationalSim...
    method getBooleanSimplexPairRelativeHomology (line 181) | public static AbstractPersistenceBasisAlgorithm<SimplexPair, BooleanSp...
    method getIntSimplexPairRelativeHomology (line 185) | public static AbstractPersistenceBasisAlgorithm<SimplexPair, IntSparse...
    method getRationalSimplexPairRelativeHomology (line 189) | public static AbstractPersistenceBasisAlgorithm<SimplexPair, ObjectSpa...
    method getAllSimplexPairAbsoluteHomologyAlgorithms (line 193) | public static List<AbstractPersistenceAlgorithm<SimplexPair>> getAllSi...

FILE: src/java/edu/stanford/math/plex4/api/Plex4.java
  class Plex4 (line 52) | public class Plex4 {
    method main (line 62) | public static void main(String[] args) {}
    method createEuclideanMetricSpace (line 70) | public static EuclideanMetricSpace createEuclideanMetricSpace(double[]...
    method estimateDiameter (line 81) | public static double estimateDiameter(AbstractIntMetricSpace metricSpa...
    method createExplicitSimplexStream (line 90) | public static ExplicitSimplexStream createExplicitSimplexStream() {
    method createExplicitSimplexStream (line 94) | public static ExplicitSimplexStream createExplicitSimplexStream(double...
    method createExplicitCellStream (line 103) | public static ExplicitCellStream createExplicitCellStream() {
    method createExplicitCellStream (line 107) | public static ExplicitCellStream createExplicitCellStream(double maxFi...
    method createVietorisRipsStream (line 120) | public static VietorisRipsStream<double[]> createVietorisRipsStream(do...
    method createVietorisRipsStream (line 133) | public static VietorisRipsStream<double[]> createVietorisRipsStream(do...
    method createVietorisRipsStream (line 147) | public static <T> VietorisRipsStream<T> createVietorisRipsStream(Abstr...
    method createVietorisRipsStream (line 160) | public static <T> VietorisRipsStream<T> createVietorisRipsStream(Abstr...
    method createVietorisRipsStream (line 172) | public static VietorisRipsStream<double[]> createVietorisRipsStream(do...
    method createVietorisRipsStream (line 185) | public static <T> VietorisRipsStream<T> createVietorisRipsStream(Abstr...
    method createLazyWitnessStream (line 198) | public static LazyWitnessStream<double[]> createLazyWitnessStream(Land...
    method createWitnessStream (line 211) | public static WitnessStream<double[]> createWitnessStream(LandmarkSele...
    method createWitnessStream (line 224) | public static WitnessStream<double[]> createWitnessStream(LandmarkSele...
    method createLazyWitnessStream (line 237) | public static LazyWitnessStream<double[]> createLazyWitnessStream(Land...
    method createMaxMinSelector (line 248) | public static MaxMinLandmarkSelector<double[]> createMaxMinSelector(do...
    method createMaxMinSelector (line 260) | public static MaxMinLandmarkSelector<double[]> createMaxMinSelector(do...
    method createRandomSelector (line 271) | public static RandomLandmarkSelector<double[]> createRandomSelector(do...
    method createMaxMinSelector (line 283) | public static <T> MaxMinLandmarkSelector<T> createMaxMinSelector(Abstr...
    method createMaxMinSelector (line 296) | public static <T> MaxMinLandmarkSelector<T> createMaxMinSelector(Abstr...
    method createRandomSelector (line 308) | public static <T> RandomLandmarkSelector<T> createRandomSelector(Abstr...
    method createExplicitSelector (line 319) | public static ExplicitLandmarkSelector<double[]> createExplicitSelecto...
    method createExplicitSelector (line 330) | public static <T> ExplicitLandmarkSelector<T> createExplicitSelector(A...
    method getDefaultSimplicialAlgorithm (line 340) | public static AbstractPersistenceAlgorithm<Simplex> getDefaultSimplici...
    method getDefaultSimplicialPairAlgorithm (line 344) | public static AbstractPersistenceAlgorithm<SimplexPair> getDefaultSimp...
    method getDefaultCellularAlgorithm (line 355) | public static AbstractPersistenceAlgorithm<Cell> getDefaultCellularAlg...
    method getModularCellularAlgorithm (line 366) | public static AbstractPersistenceAlgorithm<Cell> getModularCellularAlg...
    method getModularSimplicialAlgorithm (line 377) | public static AbstractPersistenceAlgorithm<Simplex> getModularSimplici...
    method getRationalSimplicialAlgorithm (line 387) | public static ObjectAbsoluteHomology<Fraction, Simplex> getRationalSim...
    method getRationalCellularAlgorithm (line 397) | public static AbstractPersistenceAlgorithm<Cell> getRationalCellularAl...
    method createBarcodePlot (line 409) | public static <G> void createBarcodePlot(PersistenceInvariantDescripto...
    method createHomStream (line 428) | public static <T, U> HomStream<T, U> createHomStream(AbstractFilteredS...
    method getRationalHomAlgorithm (line 436) | public static ObjectPersistenceAlgorithm<Fraction, ObjectObjectPair<Si...
    method createHomMatrixConverter (line 449) | public static DoubleMatrixConverter<Simplex, Simplex> createHomMatrixC...
    method createMatrixConverter (line 458) | public static DoubleVectorConverter<Simplex> createMatrixConverter(Abs...

FILE: src/java/edu/stanford/math/plex4/autogen/homology/BooleanAbsoluteHomology.java
  class BooleanAbsoluteHomology (line 16) | public class BooleanAbsoluteHomology<U> extends BooleanPersistentHomolog...
    method BooleanAbsoluteHomology (line 24) | public BooleanAbsoluteHomology(Comparator<U> basisComparator, int minD...
    method getAnnotatedIntervals (line 28) | @Override
    method getIntervals (line 37) | @Override

FILE: src/java/edu/stanford/math/plex4/autogen/homology/BooleanClassicalHomology.java
  class BooleanClassicalHomology (line 30) | public class BooleanClassicalHomology<U> extends AbstractPersistenceAlgo...
    method BooleanClassicalHomology (line 47) | public BooleanClassicalHomology(Comparator<U> basisComparator, int min...
    method computeIndexIntervals (line 54) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...
    method removePivotRows (line 123) | private BooleanSparseFormalSum<U> removePivotRows(U simplex, AbstractF...
    method getMaximumObject (line 157) | private U getMaximumObject(BooleanSparseFormalSum<U> chain) {

FILE: src/java/edu/stanford/math/plex4/autogen/homology/BooleanPersistenceAlgorithm.java
  class BooleanPersistenceAlgorithm (line 30) | public abstract class BooleanPersistenceAlgorithm<U> extends AbstractPer...
    method BooleanPersistenceAlgorithm (line 65) | public BooleanPersistenceAlgorithm(Comparator<U> basisComparator, int ...
    method initializeFilteredComparator (line 77) | protected void initializeFilteredComparator(AbstractFilteredStream<U> ...
    method getChainModule (line 86) | public BooleanPrimitiveFreeModule<U> getChainModule() {
    method computeIndexIntervals (line 91) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...
    method computeAnnotatedIndexIntervals (line 96) | public AnnotatedBarcodeCollection<Integer, BooleanSparseFormalSum<U>> ...
    method computeIntervalsImpl (line 107) | protected abstract BarcodeCollection<Integer> computeIntervalsImpl(Abs...
    method computeAnnotatedIntervalsImpl (line 115) | protected abstract AnnotatedBarcodeCollection<Integer, BooleanSparseFo...
    method low (line 125) | protected U low(BooleanSparseFormalSum<U> chain) {

FILE: src/java/edu/stanford/math/plex4/autogen/homology/BooleanPersistentHomology.java
  class BooleanPersistentHomology (line 31) | public abstract class BooleanPersistentHomology<U> extends BooleanPersis...
    method BooleanPersistentHomology (line 40) | public BooleanPersistentHomology(Comparator<U> basisComparator, int mi...
    method computeAnnotatedIntervalsImpl (line 44) | @Override
    method computeIntervalsImpl (line 49) | @Override
    method pHcol (line 65) | private ObjectObjectPair<THashMap<U, BooleanSparseFormalSum<U>>, THash...
    method getAnnotatedIntervals (line 143) | protected abstract AnnotatedBarcodeCollection<Integer, BooleanSparseFo...
    method getIntervals (line 147) | protected abstract BarcodeCollection<Integer> getIntervals(ObjectObjec...
    method getAnnotatedIntervals (line 151) | protected AnnotatedBarcodeCollection<Integer, BooleanSparseFormalSum<U...
    method getIntervals (line 210) | protected BarcodeCollection<Integer> getIntervals(

FILE: src/java/edu/stanford/math/plex4/autogen/homology/BooleanRelativeHomology.java
  class BooleanRelativeHomology (line 16) | public class BooleanRelativeHomology<U> extends BooleanPersistentHomolog...
    method BooleanRelativeHomology (line 24) | public BooleanRelativeHomology(Comparator<U> basisComparator, int minD...
    method getAnnotatedIntervals (line 28) | @Override
    method getIntervals (line 37) | @Override

FILE: src/java/edu/stanford/math/plex4/autogen/homology/IntAbsoluteHomology.java
  class IntAbsoluteHomology (line 17) | public class IntAbsoluteHomology<U> extends IntPersistentHomology<U> {
    method IntAbsoluteHomology (line 26) | public IntAbsoluteHomology(IntAbstractField field, Comparator<U> basis...
    method getAnnotatedIntervals (line 30) | @Override
    method getIntervals (line 39) | @Override

FILE: src/java/edu/stanford/math/plex4/autogen/homology/IntClassicalHomology.java
  class IntClassicalHomology (line 31) | public class IntClassicalHomology<U> extends AbstractPersistenceAlgorith...
    method IntClassicalHomology (line 50) | public IntClassicalHomology(IntAbstractField field, Comparator<U> basi...
    method computeIndexIntervals (line 58) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...
    method removePivotRows (line 127) | private IntSparseFormalSum<U> removePivotRows(U simplex, AbstractFilte...
    method getMaximumObject (line 164) | private U getMaximumObject(IntSparseFormalSum<U> chain) {

FILE: src/java/edu/stanford/math/plex4/autogen/homology/IntPersistenceAlgorithm.java
  class IntPersistenceAlgorithm (line 31) | public abstract class IntPersistenceAlgorithm<U> extends AbstractPersist...
    method IntPersistenceAlgorithm (line 71) | public IntPersistenceAlgorithm(IntAbstractField field, Comparator<U> b...
    method initializeFilteredComparator (line 84) | protected void initializeFilteredComparator(AbstractFilteredStream<U> ...
    method getChainModule (line 93) | public IntAlgebraicFreeModule<U> getChainModule() {
    method getField (line 102) | public IntAbstractField getField() {
    method computeIndexIntervals (line 106) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...
    method computeAnnotatedIndexIntervals (line 111) | public AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> comp...
    method computeIntervalsImpl (line 122) | protected abstract BarcodeCollection<Integer> computeIntervalsImpl(Abs...
    method computeAnnotatedIntervalsImpl (line 130) | protected abstract AnnotatedBarcodeCollection<Integer, IntSparseFormal...
    method low (line 140) | protected U low(IntSparseFormalSum<U> chain) {

FILE: src/java/edu/stanford/math/plex4/autogen/homology/IntPersistentHomology.java
  class IntPersistentHomology (line 32) | public abstract class IntPersistentHomology<U> extends IntPersistenceAlg...
    method IntPersistentHomology (line 42) | public IntPersistentHomology(IntAbstractField field, Comparator<U> bas...
    method computeAnnotatedIntervalsImpl (line 46) | @Override
    method computeIntervalsImpl (line 51) | @Override
    method pHcol (line 67) | private ObjectObjectPair<THashMap<U, IntSparseFormalSum<U>>, THashMap<...
    method getAnnotatedIntervals (line 145) | protected abstract AnnotatedBarcodeCollection<Integer, IntSparseFormal...
    method getIntervals (line 149) | protected abstract BarcodeCollection<Integer> getIntervals(ObjectObjec...
    method getAnnotatedIntervals (line 153) | protected AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> g...
    method getIntervals (line 212) | protected BarcodeCollection<Integer> getIntervals(

FILE: src/java/edu/stanford/math/plex4/autogen/homology/IntRelativeHomology.java
  class IntRelativeHomology (line 17) | public class IntRelativeHomology<U> extends IntPersistentHomology<U> {
    method IntRelativeHomology (line 26) | public IntRelativeHomology(IntAbstractField field, Comparator<U> basis...
    method getAnnotatedIntervals (line 30) | @Override
    method getIntervals (line 39) | @Override

FILE: src/java/edu/stanford/math/plex4/autogen/homology/ObjectAbsoluteHomology.java
  class ObjectAbsoluteHomology (line 17) | public class ObjectAbsoluteHomology<F, U> extends ObjectPersistentHomolo...
    method ObjectAbsoluteHomology (line 26) | public ObjectAbsoluteHomology(ObjectAbstractField<F> field, Comparator...
    method getAnnotatedIntervals (line 30) | @Override
    method getIntervals (line 39) | @Override

FILE: src/java/edu/stanford/math/plex4/autogen/homology/ObjectClassicalHomology.java
  class ObjectClassicalHomology (line 32) | public class ObjectClassicalHomology<F, U> extends AbstractPersistenceAl...
    method ObjectClassicalHomology (line 51) | public ObjectClassicalHomology(ObjectAbstractField<F> field, Comparato...
    method computeIndexIntervals (line 59) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...
    method removePivotRows (line 128) | private ObjectSparseFormalSum<F, U> removePivotRows(U simplex, Abstrac...
    method getMaximumObject (line 165) | private U getMaximumObject(ObjectSparseFormalSum<F, U> chain) {

FILE: src/java/edu/stanford/math/plex4/autogen/homology/ObjectPersistenceAlgorithm.java
  class ObjectPersistenceAlgorithm (line 32) | public abstract class ObjectPersistenceAlgorithm<F, U> extends AbstractP...
    method ObjectPersistenceAlgorithm (line 72) | public ObjectPersistenceAlgorithm(ObjectAbstractField<F> field, Compar...
    method initializeFilteredComparator (line 85) | protected void initializeFilteredComparator(AbstractFilteredStream<U> ...
    method getChainModule (line 94) | public ObjectAlgebraicFreeModule<F, U> getChainModule() {
    method getField (line 103) | public ObjectAbstractField<F> getField() {
    method computeIndexIntervals (line 107) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...
    method computeAnnotatedIndexIntervals (line 112) | public AnnotatedBarcodeCollection<Integer, ObjectSparseFormalSum<F, U>...
    method computeIntervalsImpl (line 123) | protected abstract BarcodeCollection<Integer> computeIntervalsImpl(Abs...
    method computeAnnotatedIntervalsImpl (line 131) | protected abstract AnnotatedBarcodeCollection<Integer, ObjectSparseFor...
    method low (line 141) | protected U low(ObjectSparseFormalSum<F, U> chain) {

FILE: src/java/edu/stanford/math/plex4/autogen/homology/ObjectPersistentHomology.java
  class ObjectPersistentHomology (line 32) | public abstract class ObjectPersistentHomology<F, U> extends ObjectPersi...
    method ObjectPersistentHomology (line 42) | public ObjectPersistentHomology(ObjectAbstractField<F> field, Comparat...
    method computeAnnotatedIntervalsImpl (line 46) | @Override
    method computeIntervalsImpl (line 51) | @Override
    method pHcol (line 67) | private ObjectObjectPair<THashMap<U, ObjectSparseFormalSum<F, U>>, THa...
    method getAnnotatedIntervals (line 145) | protected abstract AnnotatedBarcodeCollection<Integer, ObjectSparseFor...
    method getIntervals (line 149) | protected abstract BarcodeCollection<Integer> getIntervals(ObjectObjec...
    method getAnnotatedIntervals (line 153) | protected AnnotatedBarcodeCollection<Integer, ObjectSparseFormalSum<F,...
    method getIntervals (line 212) | protected BarcodeCollection<Integer> getIntervals(

FILE: src/java/edu/stanford/math/plex4/autogen/homology/ObjectRelativeHomology.java
  class ObjectRelativeHomology (line 17) | public class ObjectRelativeHomology<F, U> extends ObjectPersistentHomolo...
    method ObjectRelativeHomology (line 26) | public ObjectRelativeHomology(ObjectAbstractField<F> field, Comparator...
    method getAnnotatedIntervals (line 30) | @Override
    method getIntervals (line 39) | @Override

FILE: src/java/edu/stanford/math/plex4/bottleneck/BottleneckDistance.java
  class BottleneckDistance (line 10) | public class BottleneckDistance {
    method truncate (line 12) | public static List<Interval<Double>> truncate(List<Interval<Double>> A...
    method filterLargest (line 36) | public static List<Interval<Double>> filterLargest(List<Interval<Doubl...
    method computeBottleneckDistance (line 66) | public static double computeBottleneckDistance(double[][] A, double[][...
    method computeBottleneckDistance (line 82) | public static double computeBottleneckDistance(List<Interval<Double>> ...
    method distanceToDiagonal (line 121) | static double distanceToDiagonal(Interval<Double> A) {
    method distance (line 129) | static double distance(Interval<Double> A, Interval<Double> B) {

FILE: src/java/edu/stanford/math/plex4/bottleneck/FlowEdge.java
  class FlowEdge (line 3) | public class FlowEdge {
    method FlowEdge (line 10) | public FlowEdge(int source, int dest, int capacity) {
    method getCapacity (line 16) | public int getCapacity() {
    method setCapacity (line 20) | public void setCapacity(int capacity) {
    method getSource (line 24) | public int getSource() {
    method getDest (line 28) | public int getDest() {
    method hashCode (line 32) | @Override
    method equals (line 41) | @Override
    method getReverseEdge (line 57) | public FlowEdge getReverseEdge() {
    method setReverseEdge (line 61) | public void setReverseEdge(FlowEdge reverseEdge) {
    method toString (line 65) | @Override

FILE: src/java/edu/stanford/math/plex4/bottleneck/FlowNetwork.java
  class FlowNetwork (line 12) | public class FlowNetwork {
    method addEdge (line 17) | public void addEdge(int source, int destination, int weight) {
    method getEdges (line 39) | protected Set<FlowEdge> getEdges(int source) {
    method getFlow (line 43) | protected int getFlow(FlowEdge edge) {
    method incrementFlow (line 47) | protected void incrementFlow(FlowEdge edge, int increment) {
    method maxFlow (line 56) | public int maxFlow(int source, int sink) {
    method findPath (line 76) | protected List<ObjectIntPair<FlowEdge>> findPath(int source, int sink,...
    method minValue (line 97) | protected <T> int minValue(List<ObjectIntPair<T>> list) {
    method contains (line 109) | protected <T> boolean contains(Iterable<T> collection, T edge) {

FILE: src/java/edu/stanford/math/plex4/bottleneck/FordFulkerson.java
  class FordFulkerson (line 18) | public class FordFulkerson {
    method maxFlow (line 33) | public int maxFlow(FordFulkersonNode[] v, FordFulkersonEdge[] e, int s...
    method solve (line 52) | protected void solve() {
    method rdb (line 95) | protected void rdb() {
    method stpath (line 123) | protected void stpath() {

FILE: src/java/edu/stanford/math/plex4/bottleneck/FordFulkersonEdge.java
  class FordFulkersonEdge (line 11) | public class FordFulkersonEdge {
    method FordFulkersonEdge (line 31) | public FordFulkersonEdge(int rndd_plus, int rndd_minus, int capacity) {
    method FordFulkersonEdge (line 37) | public FordFulkersonEdge(int rndd_plus, int rndd_minus, int capacity,
    method toString (line 50) | @Override

FILE: src/java/edu/stanford/math/plex4/bottleneck/FordFulkersonNode.java
  class FordFulkersonNode (line 12) | public class FordFulkersonNode {
    method FordFulkersonNode (line 21) | public FordFulkersonNode(String name) {
    method toString (line 28) | @Override

FILE: src/java/edu/stanford/math/plex4/bottleneck/WeightedBipartiteGraph.java
  class WeightedBipartiteGraph (line 10) | public class WeightedBipartiteGraph {
    class WeightedEdge (line 11) | class WeightedEdge {
    method WeightedBipartiteGraph (line 22) | public WeightedBipartiteGraph(int partitionSize) {
    method addEdge (line 26) | public void addEdge(int source, int destination, double weight) {
    method filterByMaximum (line 36) | public WeightedBipartiteGraph filterByMaximum(double maximumWeight) {
    method computeMaximumCardinalityMatching (line 67) | public int computeMaximumCardinalityMatching() {
    method hasPerfectMatching (line 135) | public boolean hasPerfectMatching() {
    method computePerfectMatchingThreshold (line 148) | public double computePerfectMatchingThreshold() {

FILE: src/java/edu/stanford/math/plex4/examples/CellComplexOperations.java
  class CellComplexOperations (line 17) | public class CellComplexOperations {
    method disjointUnion (line 26) | public static ExplicitCellStream disjointUnion(ExplicitCellStream stre...
    method identifyPoints (line 46) | public static void identifyPoints(ExplicitCellStream stream, int[] ver...

FILE: src/java/edu/stanford/math/plex4/examples/CellStreamExamples.java
  class CellStreamExamples (line 12) | public class CellStreamExamples {
    method getMorozovJohanssonExample (line 20) | public static ExplicitCellStream getMorozovJohanssonExample() {
    method getCellularSphere (line 49) | public static ExplicitCellStream getCellularSphere(int dimension) {
    method getCellularTorus (line 65) | public static ExplicitCellStream getCellularTorus() {
    method getCellularKleinBottle (line 83) | public static ExplicitCellStream getCellularKleinBottle() {
    method getCellularRP2 (line 101) | public static ExplicitCellStream getCellularRP2() {
    method getCellularMobiusBand (line 119) | public static ExplicitCellStream getCellularMobiusBand() {

FILE: src/java/edu/stanford/math/plex4/examples/DeSilvaMorozovJohanssonExample.java
  class DeSilvaMorozovJohanssonExample (line 20) | public class DeSilvaMorozovJohanssonExample<R> {
    method DeSilvaMorozovJohanssonExample (line 36) | public DeSilvaMorozovJohanssonExample(ObjectAbstractField<R> field) {
    method initialize (line 42) | private ExplicitCellStream initialize() {
    method getCellComplex (line 89) | public ExplicitCellStream getCellComplex() {
    method getAbsoluteHomologyBarcodes (line 98) | public AnnotatedBarcodeCollection<Integer, ObjectSparseFormalSum<R, Ce...
    method getRelativeHomologyBarcodes (line 107) | public AnnotatedBarcodeCollection<Integer, ObjectSparseFormalSum<R, Ce...
    method getAbsoluteCohomologyBarcodes (line 116) | public AnnotatedBarcodeCollection<Integer, ObjectSparseFormalSum<R, Ce...
    method getRelativeCohomologyBarcodes (line 125) | public AnnotatedBarcodeCollection<Integer, ObjectSparseFormalSum<R, Ce...

FILE: src/java/edu/stanford/math/plex4/examples/PointCloudExamples.java
  class PointCloudExamples (line 15) | public class PointCloudExamples {
    method getHouseExample (line 21) | public static double[][] getHouseExample() {
    method getSquare (line 36) | public static double[][] getSquare() {
    method getEquispacedCirclePoints (line 52) | public static double[][] getEquispacedCirclePoints(int n) {
    method getRandomCirclePoints (line 70) | public static double[][] getRandomCirclePoints(int n) {
    method getOctahedronVertices (line 90) | public static double[][] getOctahedronVertices() {
    method getTetrahedronVertices (line 108) | public static double[][] getTetrahedronVertices() {
    method getAnnulusVertices (line 120) | public static double[][] getAnnulusVertices(int width, int length) {
    method getIcosahedronVertices (line 142) | public static double[][] getIcosahedronVertices() {
    method getRandomSpherePoints (line 170) | public static double[][] getRandomSpherePoints(int n, int d) {
    method getGaussianPoints (line 189) | public static double[][] getGaussianPoints(int n, int d) {
    method getRandomTorusPoints (line 207) | public static double[][] getRandomTorusPoints(int n, double r, double ...
    method getRandomTrefoilKnotPoints (line 221) | public static double[][] getRandomTrefoilKnotPoints(int n) {
    method getRandomSphereProductPoints (line 243) | public static double[][] getRandomSphereProductPoints(int numPoints, i...
    method getRandomFigure8Points (line 271) | public static double[][] getRandomFigure8Points(int n) {
    method getDisjointPatches (line 294) | public static double[][] getDisjointPatches(int n) {

FILE: src/java/edu/stanford/math/plex4/examples/SimplexStreamExamples.java
  class SimplexStreamExamples (line 20) | public class SimplexStreamExamples {
    method getZomorodianCarlssonExample (line 27) | public static ExplicitStream<Simplex> getZomorodianCarlssonExample() {
    method getFilteredTriangle (line 57) | public static ExplicitStream<Simplex> getFilteredTriangle() {
    method getTriangle (line 79) | public static ExplicitStream<Simplex> getTriangle() {
    method getTetrahedron (line 89) | public static ExplicitStream<Simplex> getTetrahedron() {
    method getSimplicialSphere (line 99) | public static ExplicitStream<Simplex> getSimplicialSphere(int dimensio...
    method getTorus (line 117) | public static ExplicitStream<Simplex> getTorus() {
    method getCircle (line 197) | public static ExplicitStream<Simplex> getCircle(int m) {
    method getOctahedron (line 217) | public static ExplicitStream<Simplex> getOctahedron() {
    method getIcosahedron (line 258) | public static ExplicitSimplexStream getIcosahedron() {
    method getAnnulus (line 296) | public static ExplicitSimplexStream getAnnulus(int width, int length) {
    method createGraphComplex (line 347) | public static ExplicitSimplexStream createGraphComplex(AbstractUndirec...
    method createGraphComplex (line 375) | public static ExplicitSimplexStream createGraphComplex(int[][] adjacen...

FILE: src/java/edu/stanford/math/plex4/examples/SimplicialComplexOperations.java
  class SimplicialComplexOperations (line 15) | public class SimplicialComplexOperations {
    method computeCone (line 23) | public static AbstractFilteredStream<Simplex> computeCone(AbstractFilt...
    method computeSuspension (line 62) | public static AbstractFilteredStream<Simplex> computeSuspension(Abstra...
    method computeDisjointUnion (line 107) | public static AbstractFilteredStream<Simplex> computeDisjointUnion(Abs...

FILE: src/java/edu/stanford/math/plex4/generation/GeneratorDriver.java
  class GeneratorDriver (line 16) | public class GeneratorDriver {
    method main (line 22) | public static void main(String[] args) {
    method addHomologyClasses (line 27) | private static void addHomologyClasses() {
    method generateClasses (line 46) | private static void generateClasses() {

FILE: src/java/edu/stanford/math/plex4/graph/AbstractUndirectedGraph.java
  type AbstractUndirectedGraph (line 17) | public interface AbstractUndirectedGraph extends Iterable<IntIntPair>, S...
    method getNumVertices (line 24) | public int getNumVertices();
    method getNumEdges (line 31) | public int getNumEdges();
    method containsEdge (line 41) | public boolean containsEdge(int i, int j);
    method addEdge (line 49) | public void addEdge(int i, int j);
    method removeEdge (line 57) | public void removeEdge(int i, int j);
    method getLowerNeighbors (line 66) | public TIntHashSet getLowerNeighbors(int i);
    method iterator (line 74) | public Iterator<IntIntPair> iterator();
    method getDegree (line 76) | public int getDegree(int v);
    method getNeighbors (line 77) | public int[] getNeighbors(int v);
    method getDegreeSequence (line 78) | public int[] getDegreeSequence();

FILE: src/java/edu/stanford/math/plex4/graph/AbstractWeightedUndirectedGraph.java
  type AbstractWeightedUndirectedGraph (line 10) | public interface AbstractWeightedUndirectedGraph extends AbstractUndirec...
    method getWeight (line 18) | public double getWeight(int i, int j);
    method addEdge (line 27) | public void addEdge(int i, int j, double weight);

FILE: src/java/edu/stanford/math/plex4/graph/UndirectedListEdgeIterator.java
  class UndirectedListEdgeIterator (line 19) | public class UndirectedListEdgeIterator implements Iterator<IntIntPair> {
    method UndirectedListEdgeIterator (line 33) | public UndirectedListEdgeIterator(TIntObjectHashMap<TIntHashSet> adjac...
    method hasNext (line 45) | public boolean hasNext() {
    method next (line 58) | public IntIntPair next() {
    method remove (line 74) | public void remove() {

FILE: src/java/edu/stanford/math/plex4/graph/UndirectedListGraph.java
  class UndirectedListGraph (line 31) | public class UndirectedListGraph implements AbstractUndirectedGraph {
    method UndirectedListGraph (line 53) | public UndirectedListGraph(int numVertices) {
    method UndirectedListGraph (line 58) | public UndirectedListGraph(final int numVertices, final TIntObjectHash...
    method UndirectedListGraph (line 70) | public UndirectedListGraph(AbstractUndirectedGraph graph) {
    method UndirectedListGraph (line 86) | public UndirectedListGraph(int[][] adjacencyMatrix) {
    method addEdge (line 104) | public void addEdge(int i, int j) {
    method containsEdge (line 133) | public boolean containsEdge(int i, int j) {
    method getNumEdges (line 147) | public int getNumEdges() {
    method getNumVertices (line 167) | public int getNumVertices() {
    method removeEdge (line 176) | public void removeEdge(int i, int j) {
    method getLowerNeighbors (line 198) | public TIntHashSet getLowerNeighbors(int i) {
    method iterator (line 206) | public Iterator<IntIntPair> iterator() {
    method getDegree (line 210) | public int getDegree(int v) {
    method getDegreeSequence (line 214) | public int[] getDegreeSequence() {
    method getNeighbors (line 224) | public int[] getNeighbors(int v) {

FILE: src/java/edu/stanford/math/plex4/graph/UndirectedWeightedListGraph.java
  class UndirectedWeightedListGraph (line 27) | public class UndirectedWeightedListGraph implements AbstractWeightedUndi...
    method UndirectedWeightedListGraph (line 39) | public UndirectedWeightedListGraph(int numVertices) {
    method addEdge (line 46) | public void addEdge(int i, int j, double weight) {
    method getWeight (line 69) | public double getWeight(int i, int j) {
    method addEdge (line 83) | public void addEdge(int i, int j) {
    method containsEdge (line 90) | public boolean containsEdge(int i, int j) {
    method getNumEdges (line 97) | public int getNumEdges() {
    method getNumVertices (line 107) | public int getNumVertices() {
    method removeEdge (line 114) | public void removeEdge(int i, int j) {
    method getLowerNeighbors (line 132) | public TIntHashSet getLowerNeighbors(int i) {
    method getUnweightedAdjacencySets (line 142) | public TIntObjectHashMap<TIntHashSet> getUnweightedAdjacencySets() {
    method toUnweightedGraph (line 170) | public UndirectedListGraph toUnweightedGraph() {
    method iterator (line 174) | public Iterator<IntIntPair> iterator() {
    method getDegree (line 178) | public int getDegree(int v) {
    method getDegreeSequence (line 182) | public int[] getDegreeSequence() {
    method getNeighbors (line 192) | public int[] getNeighbors(int v) {
    method getWeights (line 207) | public Set<Double> getWeights() {

FILE: src/java/edu/stanford/math/plex4/graph/io/GraphDotWriter.java
  class GraphDotWriter (line 11) | public class GraphDotWriter implements ObjectWriter<AbstractUndirectedGr...
    method writeToFile (line 13) | public void writeToFile(AbstractUndirectedGraph object, String path) t...
    method getExtension (line 39) | public String getExtension() {

FILE: src/java/edu/stanford/math/plex4/graph/metric/GraphMetricFactory.java
  type GraphMetricFactory (line 13) | public interface GraphMetricFactory {
    method createMetricSpace (line 21) | public AbstractIntMetricSpace createMetricSpace(AbstractUndirectedGrap...

FILE: src/java/edu/stanford/math/plex4/graph/metric/ShortestPathMetric.java
  class ShortestPathMetric (line 19) | public class ShortestPathMetric implements GraphMetricFactory {
    method ShortestPathMetric (line 21) | private ShortestPathMetric(){}
    method getInstance (line 23) | public static ShortestPathMetric getInstance() {
    method createMetricSpace (line 27) | public AbstractIntMetricSpace createMetricSpace(AbstractUndirectedGrap...

FILE: src/java/edu/stanford/math/plex4/graph/random/BAGraph.java
  class BAGraph (line 20) | public class BAGraph extends GraphInstanceGenerator {
    method BAGraph (line 25) | public BAGraph(int n, int m) {
    method generate (line 44) | @Override
    method whichSegmentHasX (line 82) | protected int whichSegmentHasX(double[] p, double x) {
    method getProbabilityPartition (line 102) | protected double[] getProbabilityPartition(int[] d) {
    method makeStarterGraph (line 136) | protected AbstractUndirectedGraph makeStarterGraph(int size, AbstractU...
    method toString (line 152) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/BinaryHierarchicalGraph.java
  class BinaryHierarchicalGraph (line 19) | public class BinaryHierarchicalGraph extends GraphInstanceGenerator {
    method BinaryHierarchicalGraph (line 40) | public BinaryHierarchicalGraph(int n) {
    method BinaryHierarchicalGraph (line 51) | public BinaryHierarchicalGraph(int n, double maxProbability) {
    method BinaryHierarchicalGraph (line 65) | protected BinaryHierarchicalGraph(int n, boolean dummy) {
    method getProbabilities (line 70) | public double[] getProbabilities() {
    method generate (line 74) | @Override
    method construct (line 97) | protected AbstractUndirectedGraph construct(double maxProbability) {
    method getProbabilities (line 136) | protected double[] getProbabilities(int k, double dampingFactor) {
    method constructEdges (line 159) | protected AbstractUndirectedGraph constructEdges(int n0, int n1, int k...
    method getTreeDepth (line 192) | protected int getTreeDepth(int n) {
    method toString (line 205) | @Override
    method debug (line 210) | protected void debug(String msg) {

FILE: src/java/edu/stanford/math/plex4/graph/random/BinaryTree.java
  class BinaryTree (line 10) | public class BinaryTree {
    method BinaryTree (line 29) | public BinaryTree(int n) {
    method getMaxDepth (line 36) | public int getMaxDepth() {
    method getDepth (line 52) | public int getDepth(int i) {
    method getCommonAncestor (line 67) | public int getCommonAncestor(int i, int j) {
    method commonAncestorDepth (line 110) | public int commonAncestorDepth(int i, int j) {

FILE: src/java/edu/stanford/math/plex4/graph/random/BinaryTreeGraph.java
  class BinaryTreeGraph (line 10) | public class BinaryTreeGraph extends GraphInstanceGenerator {
    method BinaryTreeGraph (line 14) | public BinaryTreeGraph(int n) {
    method generate (line 18) | @Override
    method toString (line 66) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/CircleGraph.java
  class CircleGraph (line 12) | public class CircleGraph extends GraphInstanceGenerator {
    method CircleGraph (line 20) | public CircleGraph(int numNodes, int numNeighbors,
    method generate (line 27) | @Override
    method generateWithRewiring (line 38) | protected AbstractUndirectedGraph generateWithRewiring(AbstractUndirec...
    method toString (line 67) | @Override
    method correctBettiSequence (line 94) | public String correctBettiSequence() {

FILE: src/java/edu/stanford/math/plex4/graph/random/ClusteredERGraph.java
  class ClusteredERGraph (line 21) | public class ClusteredERGraph extends GraphInstanceGenerator {
    method ClusteredERGraph (line 36) | public ClusteredERGraph(int clusterCount) {
    method defineCluster (line 48) | public void defineCluster(int index, int size, double param) {
    method linkClusters (line 61) | public void linkClusters(int srcIndex, int destIndex, int edgeCount) {
    method generate (line 67) | @Override
    method linkClustersInPlace (line 106) | protected void linkClustersInPlace(AbstractUndirectedGraph graph, int ...
    method getRandomIntInRange (line 122) | protected int getRandomIntInRange(int x0, int x1) {
    method makeClusterInPlace (line 132) | protected void makeClusterInPlace(AbstractUndirectedGraph graph, int s...
    method explain (line 147) | public String explain() {
    method toString (line 172) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/ErdosRenyiGraph.java
  class ErdosRenyiGraph (line 20) | public class ErdosRenyiGraph extends GraphInstanceGenerator {
    method ErdosRenyiGraph (line 30) | public ErdosRenyiGraph(int n, double p) {
    method generate (line 36) | @Override
    method toString (line 59) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/ForestFireGraph.java
  class ForestFireGraph (line 20) | public class ForestFireGraph extends GraphInstanceGenerator {
    method ForestFireGraph (line 30) | public ForestFireGraph(int n, double forwardBurningProbability,
    method generate (line 37) | @Override
    method burnNodes (line 66) | private AbstractUndirectedGraph burnNodes(int v, int w, int t, Abstrac...
    method toString (line 101) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/GraphInstanceGenerator.java
  class GraphInstanceGenerator (line 14) | public abstract class GraphInstanceGenerator implements Serializable {
    type ImplementationType (line 17) | public enum ImplementationType {
    method GraphInstanceGenerator (line 24) | public GraphInstanceGenerator() {
    method GraphInstanceGenerator (line 28) | public GraphInstanceGenerator(ImplementationType implementationType) {
    method setImplementationType (line 32) | public void setImplementationType(ImplementationType implementationTyp...
    method initializeGraph (line 36) | protected AbstractUndirectedGraph initializeGraph(int numNodes) {
    method generate (line 44) | public abstract AbstractUndirectedGraph generate();

FILE: src/java/edu/stanford/math/plex4/graph/random/HierarchicalERGraph.java
  class HierarchicalERGraph (line 11) | public class HierarchicalERGraph extends BinaryHierarchicalGraph {
    method HierarchicalERGraph (line 30) | public HierarchicalERGraph(int n, int m, double maxProbability,
    method roundUpToPowerOf2 (line 39) | protected static int roundUpToPowerOf2(int m) {
    method getProbabilities (line 59) | protected double[] getProbabilities(int k, double dampingFactor) {
    method getERHierarchyLevelCount (line 87) | protected int getERHierarchyLevelCount(int totalLevels) {
    method toString (line 96) | @Override
    method getErParameter (line 103) | public double getErParameter() {
    method getHgLeafCount (line 107) | public int getHgLeafCount() {
    method getRootedGraphSize (line 111) | public int getRootedGraphSize() {

FILE: src/java/edu/stanford/math/plex4/graph/random/KNearestNeighborsGraph.java
  class KNearestNeighborsGraph (line 16) | public class KNearestNeighborsGraph extends ManifoldGraph {
    method KNearestNeighborsGraph (line 20) | public KNearestNeighborsGraph(int size, int dimension, int k) {
    method distance (line 24) | @Override
    method generatePoints (line 29) | @Override
    method toString (line 34) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/ManifoldGraph.java
  class ManifoldGraph (line 16) | public abstract class ManifoldGraph extends GraphInstanceGenerator {
    method ManifoldGraph (line 31) | protected ManifoldGraph(int size, int dimension, int k) {
    method generate (line 37) | @Override
    method generateUniformPoints (line 63) | protected void generateUniformPoints() {
    method generatePoints (line 70) | protected abstract void generatePoints();
    method distance (line 79) | protected abstract double distance(double[] x, double[] y);
    method getNearestNeighbors (line 88) | protected int[] getNearestNeighbors(int index) {

FILE: src/java/edu/stanford/math/plex4/graph/random/PrescribedDegrees.java
  class PrescribedDegrees (line 16) | public class PrescribedDegrees extends GraphInstanceGenerator {
    method PrescribedDegrees (line 22) | public PrescribedDegrees(int[] degreeSequence) {
    method generate (line 42) | @Override
    method erdosGallaiCriteria (line 95) | protected static boolean erdosGallaiCriteria(int[] d, int k) {
    method isGraphical (line 119) | public static boolean isGraphical(int[] d) {
    method whichSegmentHasX (line 153) | protected int whichSegmentHasX(double[] p, double x) {
    method getCandidateList (line 173) | protected int[] getCandidateList(int[] d, int i, AbstractUndirectedGra...
    method getProbabilityPartition (line 199) | protected double[] getProbabilityPartition(int[] d) {
    method multiMinus (line 234) | protected int[] multiMinus(int[] ds, int i, int j) {
    method minPositivePosition (line 248) | public static int minPositivePosition(int[] arr) {
    method toString (line 259) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/RandomGeometricGraph.java
  class RandomGeometricGraph (line 17) | public class RandomGeometricGraph extends GraphInstanceGenerator {
    method RandomGeometricGraph (line 32) | public RandomGeometricGraph(int n, int d, double r) {
    method generate (line 39) | @Override
    method distance (line 65) | protected double distance(double[] x, double[] y) {
    method toString (line 79) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/SphereGraph.java
  class SphereGraph (line 10) | public class SphereGraph extends ManifoldGraph {
    method SphereGraph (line 15) | public SphereGraph(int size, int k) {
    method distance (line 19) | @Override
    method generatePoints (line 24) | @Override
    method toString (line 29) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/StochasticBlockmodel.java
  class StochasticBlockmodel (line 8) | public class StochasticBlockmodel extends GraphInstanceGenerator {
    method StochasticBlockmodel (line 14) | public StochasticBlockmodel(int n, double[][] probabilityMatrix) {
    method generate (line 19) | @Override
    method toString (line 50) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/random/TorusGraph.java
  class TorusGraph (line 5) | public class TorusGraph extends ManifoldGraph {
    method TorusGraph (line 9) | public TorusGraph(int size, int dimension, int k) {
    method TorusGraph (line 13) | public TorusGraph(int size, int k) {
    method distance (line 17) | @Override
    method generatePoints (line 36) | @Override
    method toString (line 41) | @Override

FILE: src/java/edu/stanford/math/plex4/graph/utility/GraphUtility.java
  class GraphUtility (line 19) | public class GraphUtility {
    method toGeometricSimplexStream (line 21) | public static GeometricSimplexStream toGeometricSimplexStream(Abstract...
    method toSimplexStream (line 38) | public static ExplicitSimplexStream toSimplexStream(AbstractUndirected...
    method computeShortestPaths (line 63) | public static double[][] computeShortestPaths(AbstractUndirectedGraph ...
    method getAdjacencyMatrix (line 97) | public static int[][] getAdjacencyMatrix(AbstractUndirectedGraph graph) {
    method getSparseAdjacencyMatrix (line 118) | public static IntSparseMatrix getSparseAdjacencyMatrix(AbstractUndirec...
    method getAdjacencyMatrix (line 138) | public static double[][] getAdjacencyMatrix(AbstractWeightedUndirected...
    method getSparseAdjacencyMatrix (line 159) | public static DoubleSparseMatrix getSparseAdjacencyMatrix(AbstractWeig...
    method getLaplacianMatrix (line 180) | public static int[][] getLaplacianMatrix(AbstractUndirectedGraph graph) {
    method getSparseLaplacianMatrix (line 207) | public static IntSparseMatrix getSparseLaplacianMatrix(AbstractUndirec...
    method getLaplacianMatrix (line 234) | public static double[][] getLaplacianMatrix(AbstractWeightedUndirected...
    method getSparseLaplacianMatrix (line 262) | public static DoubleSparseMatrix getSparseLaplacianMatrix(AbstractWeig...

FILE: src/java/edu/stanford/math/plex4/homology/barcodes/AnnotatedBarcodeCollection.java
  class AnnotatedBarcodeCollection (line 7) | public class AnnotatedBarcodeCollection<T extends Comparable<T>, G> exte...
    method setLeftClosedDefault (line 17) | public void setLeftClosedDefault(boolean value) {
    method setRightClosedDefault (line 27) | public void setRightClosedDefault(boolean value) {
    method addInterval (line 41) | public void addInterval(int dimension, T start, T end, G generatingCyc...
    method addRightInfiniteInterval (line 54) | public void addRightInfiniteInterval(int dimension, T start, G generat...
    method addLeftInfiniteInterval (line 67) | public void addLeftInfiniteInterval(int dimension, T end, G generating...
    method getInfiniteIntervals (line 71) | public AnnotatedBarcodeCollection<T, G> getInfiniteIntervals() {
    method getBettiNumbersMap (line 91) | public Map<Integer, Integer> getBettiNumbersMap(T point) {
    method filterByMaxDimension (line 112) | public AnnotatedBarcodeCollection<T, G> filterByMaxDimension(int maxDi...
    method filterPositiveMeasureIntervals (line 136) | public AnnotatedBarcodeCollection<T, G> filterPositiveMeasureIntervals...
    method filterEvenIntervals (line 162) | public static <G> AnnotatedBarcodeCollection<Integer, G> filterEvenInt...

FILE: src/java/edu/stanford/math/plex4/homology/barcodes/BarcodeCollection.java
  class BarcodeCollection (line 5) | public class BarcodeCollection<T extends Comparable<T>> extends Annotate...
    method addInterval (line 16) | public void addInterval(int dimension, T start, T end) {
    method addRightInfiniteInterval (line 28) | public void addRightInfiniteInterval(int dimension, T start) {
    method addLeftInfiniteInterval (line 40) | public void addLeftInfiniteInterval(int dimension, T end) {
    method addInterval (line 44) | public void addInterval(int dimension, Interval<T> interval) {
    method forgetGeneratorType (line 48) | public static <T extends Comparable<T>, G> BarcodeCollection<T> forget...

FILE: src/java/edu/stanford/math/plex4/homology/barcodes/BarcodeUtility.java
  class BarcodeUtility (line 11) | public class BarcodeUtility {
    method getEndpoints (line 27) | public static <G> double[][] getEndpoints(AnnotatedBarcodeCollection<D...
    method getEndpoints (line 48) | public static double[][] getEndpoints(List<Interval<Double>> intervals...
    method getLongestBarcodes (line 84) | public static List<Interval<Double>> getLongestBarcodes(List<Interval<...
    method getLongestAnnotatedBarcodes (line 104) | public static <G> List<ObjectObjectPair<Interval<Double>, G>> getLonge...
    method getLength (line 134) | public static double getLength(Interval<Double> interval) {
    method filterIntervalsByMinimumLength (line 149) | public static List<Interval<Double>> filterIntervalsByMinimumLength(It...
    method filterIntervalPairsByMinimumLength (line 168) | public static <G> List<ObjectObjectPair<Interval<Double>, G>> filterIn...

FILE: src/java/edu/stanford/math/plex4/homology/barcodes/Interval.java
  class Interval (line 15) | public class Interval<T extends Comparable<T>> implements Comparable<Int...
    method makeFiniteClosedInterval (line 32) | public static <T extends Comparable<T>> Interval<T> makeFiniteClosedIn...
    method makeFiniteRightOpenInterval (line 44) | public static <T extends Comparable<T>> Interval<T> makeFiniteRightOpe...
    method makeFiniteLeftOpenInterval (line 56) | public static <T extends Comparable<T>> Interval<T> makeFiniteLeftOpen...
    method makeFiniteOpenInterval (line 68) | public static <T extends Comparable<T>> Interval<T> makeFiniteOpenInte...
    method makeRightInfiniteClosedInterval (line 79) | public static <T extends Comparable<T>> Interval<T> makeRightInfiniteC...
    method makeRightInfiniteRightOpenInterval (line 90) | public static <T extends Comparable<T>> Interval<T> makeRightInfiniteR...
    method makeRightInfiniteLeftOpenInterval (line 101) | public static <T extends Comparable<T>> Interval<T> makeRightInfiniteL...
    method makeRightInfiniteOpenInterval (line 112) | public static <T extends Comparable<T>> Interval<T> makeRightInfiniteO...
    method makeLeftInfiniteClosedInterval (line 123) | public static <T extends Comparable<T>> Interval<T> makeLeftInfiniteCl...
    method makeLeftInfiniteRightOpenInterval (line 134) | public static <T extends Comparable<T>> Interval<T> makeLeftInfiniteRi...
    method makeLeftInfiniteLeftOpenInterval (line 145) | public static <T extends Comparable<T>> Interval<T> makeLeftInfiniteLe...
    method makeLeftInfiniteOpenInterval (line 156) | public static <T extends Comparable<T>> Interval<T> makeLeftInfiniteOp...
    method makeInterval (line 172) | public static <T extends Comparable<T>> Interval<T> makeInterval(T sta...
    method Interval (line 186) | private Interval(T start, T end, boolean isLeftClosed, boolean isRight...
    method getStart (line 200) | public T getStart() {
    method getEnd (line 209) | public T getEnd() {
    method isLeftClosed (line 218) | public boolean isLeftClosed() {
    method isRightClosed (line 227) | public boolean isRightClosed() {
    method isLeftInfinite (line 236) | public boolean isLeftInfinite() {
    method isRightInfinite (line 245) | public boolean isRightInfinite() {
    method isInfinite (line 255) | public boolean isInfinite() {
    method containsPoint (line 266) | public boolean containsPoint(T point) {
    method toString (line 290) | @Override
    method hashCode (line 323) | @Override
    method equals (line 336) | @Override
    method compareTo (line 366) | public int compareTo(Interval<T> arg0) {
    method compareTo2 (line 403) | public int compareTo2(Interval<T> arg0) {
    method getTypeCode (line 433) | private static <T extends Comparable<T>> int getTypeCode(Interval<T> i...

FILE: src/java/edu/stanford/math/plex4/homology/barcodes/IntervalLengthComparator.java
  class IntervalLengthComparator (line 5) | public class IntervalLengthComparator implements Comparator<Interval<Dou...
    method IntervalLengthComparator (line 8) | private IntervalLengthComparator() {}
    method getInstance (line 10) | public static IntervalLengthComparator getInstance() {
    method compare (line 14) | public int compare(Interval<Double> arg0, Interval<Double> arg1) {

FILE: src/java/edu/stanford/math/plex4/homology/barcodes/PersistenceInvariantDescriptor.java
  class PersistenceInvariantDescriptor (line 25) | public class PersistenceInvariantDescriptor<I, G> implements Iterable<En...
    method PersistenceInvariantDescriptor (line 30) | public PersistenceInvariantDescriptor() {}
    method addInterval (line 40) | public void addInterval(int dimension, I interval, G generator) {
    method getBettiSequence (line 63) | public int[] getBettiSequence() {
    method getBettiNumbers (line 88) | public String getBettiNumbers() {
    method toString (line 112) | @Override
    method getIntervalIterator (line 150) | public Iterator<Entry<Integer, List<I>>> getIntervalIterator() {
    method getGeneratorIterator (line 161) | public Iterator<Entry<Integer, List<G>>> getGeneratorIterator() {
    method getIntervalGeneratorPairIterator (line 172) | public Iterator<Entry<Integer, List<ObjectObjectPair<I, G>>>> getInter...
    method getDimensions (line 181) | public Set<Integer> getDimensions() {
    method getIntervalsAtDimension (line 191) | public List<I> getIntervalsAtDimension(int dimension) {
    method getGeneratorsAtDimension (line 205) | public List<G> getGeneratorsAtDimension(int dimension) {
    method getIntervalGeneratorPairsAtDimension (line 219) | public List<ObjectObjectPair<I, G>> getIntervalGeneratorPairsAtDimensi...
    method hashCode (line 230) | @Override
    method equals (line 243) | @Override
    method iterator (line 270) | public Iterator<Entry<Integer, List<ObjectObjectPair<I, G>>>> iterator...
    method union (line 283) | @SuppressWarnings("unchecked")
    method mapSetEquals (line 329) | private static <X> boolean mapSetEquals(Map<Integer, List<X>> a, Map<?...

FILE: src/java/edu/stanford/math/plex4/homology/chain_basis/Cell.java
  class Cell (line 45) | public class Cell implements PrimitiveBasisElement {
    method Cell (line 87) | public Cell() {
    method Cell (line 106) | public Cell(int dimension, Collection<Cell> boundaryElements) {
    method Cell (line 118) | public Cell(int dimension, Collection<Cell> boundaryElements, int[] at...
    method Cell (line 130) | public Cell(int dimension, Cell[] boundaryElements) {
    method Cell (line 144) | private Cell(int dimension, PrimitiveBasisElement[] boundaryElements, ...
    method getCellIds (line 162) | private static int[] getCellIds(Collection<Cell> boundaryElements) {
    method getCellIds (line 181) | private static int[] getCellIds(Cell[] boundaryElements) {
    method getBoundaryIds (line 198) | public int[] getBoundaryIds() {
    method getCellId (line 207) | public int getCellId() {
    method getBoundaryArray (line 214) | public PrimitiveBasisElement[] getBoundaryArray() {
    method getDimension (line 221) | public int getDimension() {
    method getBoundaryCoefficients (line 228) | public int[] getBoundaryCoefficients() {
    method toString (line 235) | public String toString() {
    method hashCode (line 242) | public int hashCode() {
    method equals (line 249) | public boolean equals(Object obj) {
    method verifyDimension (line 272) | public void verifyDimension() {
    method precomputeHashCode (line 291) | private int precomputeHashCode() {

FILE: src/java/edu/stanford/math/plex4/homology/chain_basis/CellComparator.java
  class CellComparator (line 17) | public class CellComparator implements Comparator<Cell> {
    method CellComparator (line 26) | private CellComparator() {}
    method getInstance (line 33) | public static CellComparator getInstance() {
    method compare (line 40) | public int compare(Cell arg0, Cell arg1) {

FILE: src/java/edu/stanford/math/plex4/homology/chain_basis/PrimitiveBasisElement.java
  type PrimitiveBasisElement (line 18) | public interface PrimitiveBasisElement {
    method getDimension (line 27) | public int getDimension();
    method getBoundaryArray (line 37) | public PrimitiveBasisElement[] getBoundaryArray();
    method getBoundaryCoefficients (line 51) | public int[] getBoundaryCoefficients();

FILE: src/java/edu/stanford/math/plex4/homology/chain_basis/Simplex.java
  class Simplex (line 26) | public class Simplex implements PrimitiveBasisElement {
    method Simplex (line 43) | public Simplex(final int[] vertices) {
    method makeSimplex (line 55) | public static Simplex makeSimplex(int... args) {
    method getDimension (line 62) | public int getDimension() {
    method getVertices (line 71) | public int[] getVertices() {
    method getBoundaryArray (line 78) | public Simplex[] getBoundaryArray() {
    method getBoundaryCoefficients (line 94) | public int[] getBoundaryCoefficients() {
    method equals (line 104) | public boolean equals(Object obj) {
    method hashCode (line 121) | public int hashCode() {
    method toString (line 128) | public String toString() {

FILE: src/java/edu/stanford/math/plex4/homology/chain_basis/SimplexComparator.java
  class SimplexComparator (line 30) | public class SimplexComparator implements Comparator<Simplex> {
    method SimplexComparator (line 40) | private SimplexComparator() {}
    method getInstance (line 47) | public static SimplexComparator getInstance() {
    method compare (line 54) | public int compare(Simplex o1, Simplex o2) {

FILE: src/java/edu/stanford/math/plex4/homology/chain_basis/SimplexPair.java
  class SimplexPair (line 5) | public class SimplexPair extends ObjectObjectPair<Simplex, Simplex> impl...
    method SimplexPair (line 7) | public SimplexPair(Simplex first, Simplex second) {
    method SimplexPair (line 11) | public SimplexPair(int[] first, int[] second) {
    method SimplexPair (line 15) | public SimplexPair(ObjectObjectPair<Simplex, Simplex> pair) {
    method createPair (line 19) | public static SimplexPair createPair(Simplex first, Simplex second) {
    method createPair (line 23) | public static SimplexPair createPair(int first, int second) {
    method createPair (line 27) | public static SimplexPair createPair(int[] first, int[] second) {
    method getBoundaryArray (line 31) | public PrimitiveBasisElement[] getBoundaryArray() {
    method getBoundaryCoefficients (line 50) | public int[] getBoundaryCoefficients() {
    method getDimension (line 68) | public int getDimension() {

FILE: src/java/edu/stanford/math/plex4/homology/chain_basis/SimplexPairComparator.java
  class SimplexPairComparator (line 5) | public class SimplexPairComparator implements Comparator<SimplexPair> {
    method SimplexPairComparator (line 17) | private SimplexPairComparator() {}
    method getInstance (line 24) | public static SimplexPairComparator getInstance() {
    method compare (line 28) | public int compare(SimplexPair arg0, SimplexPair arg1) {

FILE: src/java/edu/stanford/math/plex4/homology/filtration/ExternalConverter.java
  class ExternalConverter (line 15) | public class ExternalConverter extends FiltrationConverter {
    method ExternalConverter (line 21) | public ExternalConverter(double[] fvalues) {
    method getFiltrationIndex (line 36) | public int getFiltrationIndex(double filtrationValue) {
    method getFiltrationValue (line 60) | public double getFiltrationValue(int filtrationIndex) {
    method computeInducedFiltrationValue (line 78) | public double computeInducedFiltrationValue(double filtrationValue1, d...
    method getInitialFiltrationValue (line 87) | public double getInitialFiltrationValue() {

FILE: src/java/edu/stanford/math/plex4/homology/filtration/FiltrationConverter.java
  class FiltrationConverter (line 15) | public abstract class FiltrationConverter implements ObjectObjectFunctio...
    method getFiltrationIndex (line 23) | public abstract int getFiltrationIndex(double filtrationValue);
    method getFiltrationValue (line 31) | public abstract double getFiltrationValue(int filtrationIndex);
    method computeInducedFiltrationValue (line 42) | public abstract double computeInducedFiltrationValue(double filtration...
    method getInitialFiltrationValue (line 49) | public abstract double getInitialFiltrationValue();
    method transform (line 51) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...
    method evaluate (line 58) | public Interval<Double> evaluate(Interval<Integer> interval) {

FILE: src/java/edu/stanford/math/plex4/homology/filtration/FiltrationUtility.java
  class FiltrationUtility (line 19) | public class FiltrationUtility {
    method transform (line 21) | @SuppressWarnings("unchecked")
    method transformByIdentity (line 48) | public static <G> PersistenceInvariantDescriptor<Interval<Double>, G> ...

FILE: src/java/edu/stanford/math/plex4/homology/filtration/IdentityConverter.java
  class IdentityConverter (line 12) | public class IdentityConverter extends FiltrationConverter {
    method IdentityConverter (line 22) | private IdentityConverter(){}
    method getInstance (line 29) | public static IdentityConverter getInstance() {
    method getFiltrationIndex (line 33) | @Override
    method getFiltrationValue (line 38) | @Override
    method computeInducedFiltrationValue (line 43) | @Override
    method getInitialFiltrationValue (line 48) | @Override

FILE: src/java/edu/stanford/math/plex4/homology/filtration/IncreasingLinearConverter.java
  class IncreasingLinearConverter (line 19) | public class IncreasingLinearConverter extends FiltrationConverter {
    method IncreasingLinearConverter (line 58) | public IncreasingLinearConverter(int numDivisions, double minFiltratio...
    method IncreasingLinearConverter (line 71) | public IncreasingLinearConverter(int numDivisions, double maxFiltratio...
    method getFiltrationIndex (line 78) | public int getFiltrationIndex(double filtrationValue) {
    method getFiltrationValue (line 88) | public double getFiltrationValue(int filtrationIndex) {
    method computeInducedFiltrationValue (line 95) | public double computeInducedFiltrationValue(double filtrationValue1, d...
    method getInitialFiltrationValue (line 102) | public double getInitialFiltrationValue(){
    method getNumDivisions (line 109) | public int getNumDivisions() {
    method getMinFiltrationValue (line 116) | public double getMinFiltrationValue() {
    method getMaxFiltrationValue (line 123) | public double getMaxFiltrationValue() {
    method getDelta (line 130) | public double getDelta() {

FILE: src/java/edu/stanford/math/plex4/homology/filtration/StaticConverter.java
  class StaticConverter (line 14) | public class StaticConverter extends FiltrationConverter {
    method StaticConverter (line 23) | private StaticConverter(){}
    method getInstance (line 30) | public static StaticConverter getInstance() {
    method getFiltrationIndex (line 37) | public int getFiltrationIndex(double filtrationValue) {
    method getFiltrationValue (line 44) | public double getFiltrationValue(int filtrationIndex) {
    method computeInducedFiltrationValue (line 51) | public double computeInducedFiltrationValue(double filtrationValue1, d...
    method getInitialFiltrationValue (line 58) | public double getInitialFiltrationValue() {

FILE: src/java/edu/stanford/math/plex4/homology/interfaces/AbstractPersistenceAlgorithm.java
  class AbstractPersistenceAlgorithm (line 14) | public abstract class AbstractPersistenceAlgorithm<T> {
    method computeIndexIntervals (line 23) | public abstract BarcodeCollection<Integer> computeIndexIntervals(Abstr...
    method computeIntervals (line 31) | public BarcodeCollection<Double> computeIntervals(AbstractFilteredStre...

FILE: src/java/edu/stanford/math/plex4/homology/interfaces/AbstractPersistenceBasisAlgorithm.java
  class AbstractPersistenceBasisAlgorithm (line 15) | public abstract class AbstractPersistenceBasisAlgorithm<T, B> extends Ab...
    method computeAnnotatedIndexIntervals (line 26) | public abstract AnnotatedBarcodeCollection<Integer, B> computeAnnotate...
    method computeAnnotatedIntervals (line 36) | public AnnotatedBarcodeCollection<Double, B> computeAnnotatedIntervals...

FILE: src/java/edu/stanford/math/plex4/homology/nonautogen/DisjointSetSystem.java
  class DisjointSetSystem (line 3) | @Deprecated
    method DisjointSetSystem (line 10) | public DisjointSetSystem(int size) {
    method DisjointSetSystem (line 23) | public DisjointSetSystem(DisjointSetSystem set) {
    method grow (line 34) | public void grow(int newSize) {
    method find (line 62) | public int find(int index) {
    method union (line 71) | public void union(int x, int y) {

FILE: src/java/edu/stanford/math/plex4/homology/nonautogen/PersistentCohomologyPrototype.java
  class PersistentCohomologyPrototype (line 28) | public class PersistentCohomologyPrototype<U> extends AbstractPersistenc...
    method PersistentCohomologyPrototype (line 68) | public PersistentCohomologyPrototype(IntAbstractField field, Comparato...
    method initializeFilteredComparator (line 81) | protected void initializeFilteredComparator(AbstractFilteredStream<U> ...
    method getChainModule (line 90) | public IntAlgebraicFreeModule<U> getChainModule() {
    method getField (line 99) | public IntAbstractField getField() {
    method computeIndexIntervals (line 103) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...
    method pCohMatrix (line 108) | private BarcodeCollection<Integer> pCohMatrix(AbstractFilteredStream<U...
    method pCoh (line 218) | @SuppressWarnings("unused")
    method accumulate (line 314) | private void accumulate(IntSparseVector a, IntSparseVector b, int c, I...

FILE: src/java/edu/stanford/math/plex4/homology/utility/HomologyUtility.java
  class HomologyUtility (line 14) | public class HomologyUtility {
    method initializeDefaultBoundaryCoefficients (line 37) | private static void initializeDefaultBoundaryCoefficients() {
    method getDefaultBoundaryCoefficients (line 61) | public static int[] getDefaultBoundaryCoefficients(int length) {
    method compareIntArrays (line 99) | public static int compareIntArrays (int[] array1, int[] array2) {
    method removeIndex (line 123) | public static int[] removeIndex(final int[] array, int index) {
    method appendToArray (line 147) | public static int[] appendToArray(int[] array, int newValue) {
    method lowerEntries (line 163) | public static int[] lowerEntries(int[] array, int k) {
    method upperEntries (line 179) | public static int[] upperEntries(int[] array, int k) {
    method computeIntersection (line 196) | public static TIntHashSet computeIntersection(TIntHashSet set1, TIntHa...
    method convertIndices (line 225) | public static Simplex convertIndices(Simplex simplex, int[] conversion...
    method convertIndices (line 229) | public static int[] convertIndices(int[] vertices, int[] conversionArr...
    method deconvertIndices (line 239) | public static int[] deconvertIndices(int[] vertices, int[] conversionA...

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/AbstractHomologyTracker.java
  type AbstractHomologyTracker (line 5) | public interface AbstractHomologyTracker<K, I extends Comparable<I>, U, ...
    method add (line 6) | public void add(U sigma, K index);
    method remove (line 7) | public void remove(U sigma, K index);
    method getState (line 9) | public AbstractPersistenceTracker<K, I, G> getState();
    method isBoundary (line 11) | public boolean isBoundary(G generator);

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/AbstractPersistenceTracker.java
  type AbstractPersistenceTracker (line 7) | public interface AbstractPersistenceTracker<K, I extends Comparable<I>, ...
    method getInactiveGenerators (line 8) | public AnnotatedBarcodeCollection<I, G> getInactiveGenerators();
    method getActiveGenerators (line 9) | public Map<K, IntervalDescriptor<I, G>> getActiveGenerators();

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/BasisTrackingUtility.java
  class BasisTrackingUtility (line 25) | public class BasisTrackingUtility {
    method createNewSum (line 35) | @SuppressWarnings("unchecked")
    method low (line 56) | public static <X> X low(IntSparseFormalSum<X> chain, Comparator<X> com...
    method multiply (line 87) | public static <X, Y> IntSparseFormalSum<Y> multiply(Map<X, IntSparseFo...
    method multiply (line 116) | public static <X, Y, Z> Map<Z, IntSparseFormalSum<Y>> multiply(Map<X, ...
    method findColumnWithGivenLow (line 136) | public static <Y> int findColumnWithGivenLow(List<IntSparseFormalSum<Y...
    method findColumnWithGivenLow (line 160) | public static <X, Y> X findColumnWithGivenLow(Map<X, IntSparseFormalSu...
    method computeBoundary (line 181) | public static <X extends PrimitiveBasisElement> IntSparseFormalSum<X> ...
    method findFirstIndexContainingElement (line 209) | public static <X, Y> X findFirstIndexContainingElement(Map<X, IntSpars...
    method findLastIndexContainingElement (line 239) | public static <X, Y> X findLastIndexContainingElement(Map<X, IntSparse...
    method getAscendingIndicesContainingElement (line 269) | public static <X, Y> List<X> getAscendingIndicesContainingElement(Map<...
    method getAscendingIndicesWithGivenLow (line 284) | public static <X, Y> List<X> getAscendingIndicesWithGivenLow(Map<X, In...
    method getAscendingIndices (line 299) | public static <X, Y> List<X> getAscendingIndices(Map<X, Y> m, Comparat...
    method getPrependIndex (line 308) | public static <X> int getPrependIndex(Map<Integer, X> m) {
    method getAppendIndex (line 324) | public static <X> int getAppendIndex(Map<Integer, X> m) {
    method prependColumn (line 340) | public static <X> int prependColumn(Map<Integer, X> m, X col) {
    method appendColumn (line 346) | public static <X> int appendColumn(Map<Integer, X> m, X col) {
    method writeRow (line 352) | public static <X> void writeRow(Map<X, IntSparseFormalSum<Integer>> m,...
    method getRow (line 365) | public static <X, Y> IntSparseFormalSum<X> getRow(Map<X, IntSparseForm...
    method reduce (line 378) | public static <X, Y> ObjectObjectPair<IntSparseFormalSum<X>, IntSparse...

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/HomologyBasisTracker.java
  class HomologyBasisTracker (line 34) | public class HomologyBasisTracker<U extends PrimitiveBasisElement> imple...
    method compare (line 48) | public int compare(Integer o1, Integer o2) {
    method compare (line 54) | public int compare(U arg0, U arg1) {
    method HomologyBasisTracker (line 88) | public HomologyBasisTracker(IntAbstractField field, Comparator<U> basi...
    method log (line 95) | public static void log(String... args) {
    method getIntervalTracker (line 105) | public IntervalTracker<Integer, Integer, IntSparseFormalSum<U>> getInt...
    method getFiniteAnnotatedBarcodes (line 109) | public AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> getF...
    method getInfiniteAnnotatedBarcodes (line 113) | public AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> getI...
    method getAnnotatedBarcodes (line 117) | public AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> getA...
    method getFiniteBarcodes (line 121) | public BarcodeCollection<Integer> getFiniteBarcodes() {
    method getInfiniteBarcodes (line 125) | public BarcodeCollection<Integer> getInfiniteBarcodes() {
    method getBarcodes (line 129) | public BarcodeCollection<Integer> getBarcodes() {
    method add (line 133) | public void add(U sigma) {
    method add (line 137) | @SuppressWarnings("unchecked")
    method remove (line 209) | public void remove(U sigma) {
    method remove (line 213) | public void remove(U sigma, int externalIndex) {
    method checkInvariant (line 472) | public void checkInvariant() {
    method checkReduced (line 498) | protected <X, Y> void checkReduced(Map<X, IntSparseFormalSum<Y>> map, ...
    method isCycle (line 509) | protected boolean isCycle(IntSparseFormalSum<U> chain) {
    method isBoundary (line 516) | public boolean isBoundary(IntSparseFormalSum<U> cycle) {
    method add (line 533) | public void add(U sigma, Integer index) {
    method getStateWithoutFiniteBarcodes (line 537) | public AbstractPersistenceTracker<Integer, Integer, IntSparseFormalSum...
    method getState (line 557) | public AbstractPersistenceTracker<Integer, Integer, IntSparseFormalSum...
    method remove (line 561) | public void remove(U sigma, Integer index) {

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/IntervalDescriptor.java
  class IntervalDescriptor (line 7) | public class IntervalDescriptor<T, G> {
    method IntervalDescriptor (line 12) | public IntervalDescriptor(T start, int dimension, G generator) {
    method getStart (line 22) | public T getStart() {
    method getDimension (line 29) | public int getDimension() {
    method getGenerator (line 36) | public G getGenerator() {
    method toString (line 43) | @Override
    method hashCode (line 51) | @Override
    method equals (line 64) | @Override

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/IntervalTracker.java
  class IntervalTracker (line 13) | public class IntervalTracker<K, I extends Comparable<I>, G> implements A...
    method getActiveGenerators (line 23) | public Map<K, IntervalDescriptor<I, G>> getActiveGenerators() {
    method getInactiveGenerators (line 27) | public AnnotatedBarcodeCollection<I, G> getInactiveGenerators() {
    method setMaxDimension (line 31) | public void setMaxDimension(int maxDimension) {
    method setUseLeftClosedIntervals (line 35) | public void setUseLeftClosedIntervals(boolean value) {
    method setUseRightClosedIntervals (line 39) | public void setUseRightClosedIntervals(boolean value) {
    method containsActiveInterval (line 43) | public boolean containsActiveInterval(K key) {
    method startInterval (line 47) | public void startInterval(K key, I startIndex, int dimension, G genera...
    method endInterval (line 57) | public void endInterval(K key, I endIndex) {
    method endAllIntervals (line 78) | public void endAllIntervals(I endIndex) {
    method getAnnotatedBarcodes (line 100) | public AnnotatedBarcodeCollection<I, G> getAnnotatedBarcodes() {
    method getInfiniteAnnotatedBarcodes (line 104) | public AnnotatedBarcodeCollection<I, G> getInfiniteAnnotatedBarcodes() {
    method getFiniteAnnotatedBarcodes (line 114) | public AnnotatedBarcodeCollection<I, G> getFiniteAnnotatedBarcodes() {
    method getBarcodes (line 118) | public BarcodeCollection<I> getBarcodes() {
    method getInfiniteBarcodes (line 122) | public BarcodeCollection<I> getInfiniteBarcodes() {
    method getFiniteBarcodes (line 126) | public BarcodeCollection<I> getFiniteBarcodes() {
    method toString (line 130) | @Override

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/SimpleHomologyBasisTracker.java
  class SimpleHomologyBasisTracker (line 21) | public class SimpleHomologyBasisTracker<U extends PrimitiveBasisElement>...
    method compare (line 42) | public int compare(U arg0, U arg1) {
    method SimpleHomologyBasisTracker (line 72) | public SimpleHomologyBasisTracker(IntAbstractField field, Comparator<U...
    method add (line 80) | public void add(U sigma, Integer index) {
    method low (line 135) | private U low(IntSparseFormalSum<U> intSparseFormalSum) {
    method getState (line 139) | public IntervalTracker<Integer, Integer, IntSparseFormalSum<U>> getSta...
    method getStateWithoutFiniteBarcodes (line 199) | public IntervalTracker<Integer, Integer, IntSparseFormalSum<U>> getSta...
    method isBoundary (line 241) | public boolean isBoundary(IntSparseFormalSum<U> generator) {
    method remove (line 249) | public void remove(U sigma, Integer index) {
    method getIntervalTracker (line 253) | public IntervalTracker<Integer, Integer, IntSparseFormalSum<U>> getInt...
    method getFiniteAnnotatedBarcodes (line 257) | public AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> getF...
    method getInfiniteAnnotatedBarcodes (line 262) | public AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> getI...
    method getAnnotatedBarcodes (line 267) | public AnnotatedBarcodeCollection<Integer, IntSparseFormalSum<U>> getA...
    method getFiniteBarcodes (line 272) | public BarcodeCollection<Integer> getFiniteBarcodes() {
    method getInfiniteBarcodes (line 277) | public BarcodeCollection<Integer> getInfiniteBarcodes() {
    method getBarcodes (line 282) | public BarcodeCollection<Integer> getBarcodes() {

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/ZigZagHomology.java
  class ZigZagHomology (line 13) | public class ZigZagHomology<U extends PrimitiveBasisElement> extends Abs...
    method ZigZagHomology (line 53) | public ZigZagHomology(IntAbstractField field, Comparator<U> basisCompa...
    method initializeFilteredComparator (line 66) | protected void initializeFilteredComparator(AbstractFilteredStream<U> ...
    method computeIndexIntervals (line 70) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/InducedHomologyMappingUtility.java
  class InducedHomologyMappingUtility (line 26) | public class InducedHomologyMappingUtility {
    method include (line 28) | public static <I extends Comparable<I>, U extends PrimitiveBasisElemen...
    method project (line 126) | public static <I extends Comparable<I>, U extends PrimitiveBasisElemen...
    method computeInducedMap (line 198) | public static <K1, K2, I1 extends Comparable<I1>, I2 extends Comparabl...
    method join (line 235) | public static <K, I extends Comparable<I>, G1, G2> IntervalTracker<K, ...
    method reverse (line 300) | public static <X extends Comparable<X>, Y> Map<Y, List<X>> reverse(Map...
    method getInclusionMap (line 320) | public static <U extends PrimitiveBasisElement> ObjectObjectFunction<I...
    method getFirstGradedProjectionMap (line 330) | public static <U extends PrimitiveBasisElement, V extends ObjectObject...
    method getSecondGradedProjectionMap (line 356) | public static <U extends PrimitiveBasisElement, V extends ObjectObject...

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/SimplexStreamUtility.java
  class SimplexStreamUtility (line 9) | public class SimplexStreamUtility {
    method projectFirst (line 12) | public static <U> IntSparseFormalSum<U> projectFirst(IntSparseFormalSu...
    method projectSecond (line 23) | public static <U> IntSparseFormalSum<U> projectSecond(IntSparseFormalS...
    method filterByDimension (line 34) | public static <U extends PrimitiveBasisElement> IntSparseFormalSum<U> ...

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/VietorisRipsBootstrapper.java
  class VietorisRipsBootstrapper (line 21) | public class VietorisRipsBootstrapper {
    method VietorisRipsBootstrapper (line 30) | public VietorisRipsBootstrapper(double[][] points, double maxDistance,...
    method VietorisRipsBootstrapper (line 42) | public VietorisRipsBootstrapper(double[][] points, double maxDistance,...
    method getSubset (line 57) | public int[] getSubset(int index) {
    method performBootstrap (line 61) | public BarcodeCollection<Integer> performBootstrap() {

FILE: src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/WitnessBootstrapper.java
  class WitnessBootstrapper (line 25) | public class WitnessBootstrapper<T> {
    method WitnessBootstrapper (line 35) | public WitnessBootstrapper(AbstractSearchableMetricSpace<T> metricSpac...
    method getLandmarkSelector (line 42) | public LandmarkSelector<T> getLandmarkSelector(int index) {
    method WitnessBootstrapper (line 46) | public WitnessBootstrapper(AbstractSearchableMetricSpace<T> metricSpac...
    method performProjectionBootstrap (line 60) | public BarcodeCollection<Integer> performProjectionBootstrap() {
    method performProjectionBootstrap (line 64) | public BarcodeCollection<Integer> performProjectionBootstrap(int[] exp...

FILE: src/java/edu/stanford/math/plex4/interop/Plex3PersistenceAlgorithm.java
  class Plex3PersistenceAlgorithm (line 19) | public class Plex3PersistenceAlgorithm extends AbstractPersistenceAlgori...
    method Plex3PersistenceAlgorithm (line 27) | public Plex3PersistenceAlgorithm(int maxDimension) {
    method computeIndexIntervals (line 34) | public BarcodeCollection<Integer> computeIndexIntervals(AbstractFilter...

FILE: src/java/edu/stanford/math/plex4/interop/Plex3Stream.java
  class Plex3Stream (line 23) | public class Plex3Stream implements AbstractFilteredStream<edu.stanford....
    method Plex3Stream (line 29) | public Plex3Stream(SimplexStream plex3Stream) {
    method Plex3Stream (line 46) | public Plex3Stream(SimplexStream plex3Stream, int[] vertexMapping) {
    method finalizeStream (line 63) | public void finalizeStream() { }
    method getBoundary (line 65) | public Simplex[] getBoundary(Simplex basisElement) {
    method getBoundaryCoefficients (line 69) | public int[] getBoundaryCoefficients(Simplex basisElement) {
    method getDimension (line 73) | public int getDimension(Simplex basisElement) {
    method getFiltrationIndex (line 77) | public int getFiltrationIndex(Simplex basisElement) {
    method getFiltrationValue (line 81) | public double getFiltrationValue(Simplex basisElement) {
    method containsElement (line 88) | public boolean containsElement(Simplex basisElement) {
    method getMaximumFiltrationIndex (line 93) | public int getMaximumFiltrationIndex() {
    method getMinimumFiltrationIndex (line 97) | public int getMinimumFiltrationIndex() {
    method getSize (line 101) | public int getSize() {
    method isFinalized (line 105) | public boolean isFinalized() {
    method iterator (line 109) | public Iterator<edu.stanford.math.plex4.homology.chain_basis.Simplex> ...
    method getBasisComparator (line 113) | public Comparator<Simplex> getBasisComparator() {
    method transform (line 117) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...

FILE: src/java/edu/stanford/math/plex4/interop/Plex3ToPlex4BarcodeAdapter.java
  class Plex3ToPlex4BarcodeAdapter (line 19) | public class Plex3ToPlex4BarcodeAdapter implements ObjectObjectFunction<...
    method getInstance (line 22) | public static Plex3ToPlex4BarcodeAdapter getInstance() {
    method Plex3ToPlex4BarcodeAdapter (line 26) | private Plex3ToPlex4BarcodeAdapter(){}
    method evaluate (line 28) | public BarcodeCollection<Integer> evaluate(PersistenceInterval[] argum...

FILE: src/java/edu/stanford/math/plex4/interop/Plex3ToPlex4SimplexAdapter.java
  class Plex3ToPlex4SimplexAdapter (line 15) | public class Plex3ToPlex4SimplexAdapter implements ObjectObjectFunction<...
    method getInstance (line 19) | public static Plex3ToPlex4SimplexAdapter getInstance() {
    method getInstance (line 23) | public static Plex3ToPlex4SimplexAdapter getInstance(int[] vertexMappi...
    method Plex3ToPlex4SimplexAdapter (line 27) | private Plex3ToPlex4SimplexAdapter() {
    method Plex3ToPlex4SimplexAdapter (line 31) | private Plex3ToPlex4SimplexAdapter(int[] vertexMapping) {
    method evaluate (line 35) | public edu.stanford.math.plex4.homology.chain_basis.Simplex evaluate(S...

FILE: src/java/edu/stanford/math/plex4/io/BarcodeWriter.java
  class BarcodeWriter (line 11) | public class BarcodeWriter {
    method BarcodeWriter (line 14) | private BarcodeWriter() {}
    method getInstance (line 16) | public static BarcodeWriter getInstance() {
    method writeToFile (line 20) | public <G> void writeToFile(PersistenceInvariantDescriptor<Interval<Do...
    method getExtension (line 26) | public String getExtension() {

FILE: src/java/edu/stanford/math/plex4/io/BufferedImageWriter.java
  class BufferedImageWriter (line 13) | public class BufferedImageWriter implements ObjectWriter<BufferedImage> {
    method getInstance (line 18) | public static BufferedImageWriter getInstance(String parameter) {
    method initializeInstance (line 26) | private static void initializeInstance(String parameter) {
    method BufferedImageWriter (line 30) | private BufferedImageWriter(String encoderFormat) {
    method getDefaultEncoderFormat (line 34) | public static String getDefaultEncoderFormat() {
    method writeToFile (line 38) | public void writeToFile(BufferedImage object, String path) throws IOEx...
    method getExtension (line 54) | public String getExtension() {

FILE: src/java/edu/stanford/math/plex4/io/DoubleArrayReaderWriter.java
  class DoubleArrayReaderWriter (line 8) | public class DoubleArrayReaderWriter implements ObjectReader<double[][]>...
    method DoubleArrayReaderWriter (line 11) | private DoubleArrayReaderWriter() {}
    method getInstance (line 13) | public static DoubleArrayReaderWriter getInstance() {
    method importFromFile (line 17) | public double[][] importFromFile(String path) throws IOException {
    method getExtension (line 36) | public String getExtension() {
    method writeToFile (line 40) | public void writeToFile(double[][] object, String path) throws IOExcep...

FILE: src/java/edu/stanford/math/plex4/io/FileIOUtility.java
  class FileIOUtility (line 30) | public class FileIOUtility {
    method saveImage (line 39) | public static void saveImage(BufferedImage image, String filePath) thr...
    method writeTextFile (line 63) | public static void writeTextFile(String filePath, String contents, boo...
    method readCSVFile (line 101) | public static Table readCSVFile(String filename, String separator, boo...
    method readNumericCSVFile (line 159) | public static List<double[]> readNumericCSVFile(String filename, Strin...
    method serializeObject (line 198) | public static void serializeObject(Object obj, String destPath) throws...
    method loadObject (line 223) | public static Object loadObject(String inputPath) throws IOException {

FILE: src/java/edu/stanford/math/plex4/io/FileManager.java
  class FileManager (line 32) | public class FileManager {
    method FileManager (line 47) | private FileManager() {
    method getUniqueFilePath (line 51) | public static String getUniqueFilePath(String basename, String extenti...
    method getBaseOutputPath (line 60) | public static String getBaseOutputPath() {
    method getDailyOutputPath (line 71) | public static String getDailyOutputPath() throws IOException {
    method getUniqueOutputPath (line 85) | public static String getUniqueOutputPath() throws IOException {
    method getCategoryOutputPath (line 101) | public static String getCategoryOutputPath(String category) throws IOE...
    method getUniqueCategoryOutputPath (line 118) | public static String getUniqueCategoryOutputPath(String category) thro...
    method createDirectory (line 137) | private static String createDirectory(String directoryPath) throws IOE...
    method initializeDailyOutputPath (line 152) | private static void initializeDailyOutputPath() throws IOException {
    method initializeCategoryOutputPath (line 165) | private static void initializeCategoryOutputPath(String category) thro...
    method getTimeStamp (line 176) | private static String getTimeStamp() {
    method pause (line 185) | private static void pause() {
    method generateUniqueFileName (line 199) | public static String generateUniqueFileName() {

FILE: src/java/edu/stanford/math/plex4/io/MatlabInterface.java
  class MatlabInterface (line 15) | public class MatlabInterface{
    method getDefaultExtension (line 17) | protected static String getDefaultExtension() {
    method makeNewMatlabWriter (line 29) | public static MatlabWriter makeNewMatlabWriter(String label) throws IO...
    method finalizeMatlabWriter (line 42) | public static void finalizeMatlabWriter(MatlabWriter writer) throws IO...
    method exportScatterPlot2D (line 59) | public static void exportScatterPlot2D(MatlabWriter writer, DoubleMatr...
    method exportScatterPlot3D (line 80) | public static void exportScatterPlot3D(MatlabWriter writer, DoubleMatr...
    method exportScatterPlot2D (line 104) | public static void exportScatterPlot2D(MatlabWriter writer, DoubleMatr...
    method exportScatterPlot3D (line 139) | public static void exportScatterPlot3D(MatlabWriter writer, DoubleMatr...

FILE: src/java/edu/stanford/math/plex4/io/MatlabWriter.java
  class MatlabWriter (line 23) | public class MatlabWriter {
    method MatlabWriter (line 46) | public MatlabWriter(String filename) throws IOException {
    method close (line 55) | public void close() throws IOException {
    method turnOnCommentMode (line 63) | public void turnOnCommentMode() {
    method turnOffCommentMode (line 71) | public void turnOffCommentMode() {
    method insertComments (line 82) | protected String insertComments(String input) throws IOException {
    method writeClearAll (line 92) | public void writeClearAll() throws IOException {
    method assignValue (line 96) | public void assignValue(String varName, double value) throws IOExcepti...
    method assignValue (line 100) | public void assignValue(String varName, int value) throws IOException {
    method write (line 112) | public void write(String string) throws IOException {
    method writeLine (line 116) | public void writeLine(String string) throws IOException {
    method newLine (line 126) | public void newLine() throws IOException {
    method startNewCell (line 137) | public void startNewCell(String label) throws IOException {
    method newPlotWindow (line 141) | public void newPlotWindow() throws IOException {
    method holdOn (line 146) | public void holdOn() throws IOException {
    method holdOff (line 151) | public void holdOff() throws IOException {
    method gridOn (line 156) | public void gridOn() throws IOException {
    method gridOff (line 161) | public void gridOff() throws IOException {
    method getMarkerStyle (line 166) | public String getMarkerStyle(int index) {
    method getColorCode (line 170) | public String getColorCode(int index) {
    method getLineStyle (line 174) | public String getLineStyle(int index) {
    method getNextMarker (line 178) | public String getNextMarker() {
    method getNextColor (line 182) | public String getNextColor() {
    method getNextLineStyle (line 186) | public String getNextLineStyle() {
    method writeRowVector (line 194) | public void writeRowVector(DoubleMatrix1D array, String name) throws I...
    method writeColumnVector (line 198) | public void writeColumnVector(DoubleMatrix1D array, String name) throw...
    method writeRowVector (line 202) | public void writeRowVector(DoubleMatrix1D array) throws IOException {
    method writeColumnVector (line 206) | public void writeColumnVector(DoubleMatrix1D array) throws IOException {
    method writeRowVector (line 210) | public void writeRowVector(double[] array, String name) throws IOExcep...
    method writeColumnVector (line 214) | public void writeColumnVector(double[] array, String name) throws IOEx...
    method writeRowVector (line 218) | public void writeRowVector(double[] array) throws IOException {
    method writeColumnVector (line 222) | public void writeColumnVector(double[] array) throws IOException {
    method writeRowVector (line 226) | public void writeRowVector(int[] array, String name) throws IOException {
    method writeColumnVector (line 230) | public void writeColumnVector(int[] array, String name) throws IOExcep...
    method writeRowVector (line 234) | public void writeRowVector(int[] array) throws IOException {
    method writeColumnVector (line 238) | public void writeColumnVector(int[] array) throws IOException {
    method writeRowVector (line 242) | public <T> void writeRowVector(Iterable<T> collection) throws IOExcept...
    method writeColumnVector (line 246) | public <T> void writeColumnVector(Iterable<T> collection) throws IOExc...
    method writeRowVector (line 250) | public <T> void writeRowVector(Iterable<T> collection, String name) th...
    method writeColumnVector (line 254) | public <T> void writeColumnVector(Iterable<T> collection, String name)...
    method writeMatrix (line 262) | public void writeMatrix(DoubleMatrix2D matrix, String name) throws IOE...
    method writeMatrix (line 279) | public void writeMatrix(DoubleMatrix2D matrix) throws IOException {
    method writeSparseMatrix (line 295) | public void writeSparseMatrix(double[][] matrix, String name) throws I...
    method writeSparseVector (line 321) | public void writeSparseVector(double[] matrix, String name) throws IOE...
    method writeMatrix (line 345) | public void writeMatrix(double[][] matrix, String name) throws IOExcep...
    method writeMatrix (line 349) | public void writeMatrix(double[][] matrix) throws IOException {
    method writeMatrix (line 353) | public void writeMatrix(int[][] matrix, String name) throws IOException {
    method writeMatrix (line 357) | public void writeMatrix(int[][] matrix) throws IOException {
    method toRowVector (line 365) | public static String toRowVector(DoubleMatrix1D array, String name) {
    method toColumnVector (line 369) | public static String toColumnVector(DoubleMatrix1D array, String name) {
    method toRowVector (line 373) | public static String toRowVector(DoubleMatrix1D array) {
    method toColumnVector (line 377) | public static String toColumnVector(DoubleMatrix1D array) {
    method toRowVector (line 381) | public static String toRowVector(int[] array, String name) {
    method toColumnVector (line 385) | public static String toColumnVector(int[] array, String name) {
    method toRowVector (line 389) | public static String toRowVector(int[] array) {
    method toColumnVector (line 393) | public static String toColumnVector(int[] array) {
    method toRowVector (line 397) | public static String toRowVector(double[] array, String name) {
    method toColumnVector (line 401) | public static String toColumnVector(double[] array, String name) {
    method toRowVector (line 405) | public static String toRowVector(double[] array) {
    method toColumnVector (line 409) | public static String toColumnVector(double[] array) {
    method toRowVector (line 413) | public static <T> String toRowVector(Iterable<T> collection, String na...
    method toColumnVector (line 417) | public static <T> String toColumnVector(Iterable<T> collection, String...
    method toRowVector (line 421) | public static <T> String toRowVector(Iterable<T> collection) {
    method toColumnVector (line 425) | public static <T> String toColumnVector(Iterable<T> collection) {
    method toMatrix (line 433) | public static String toMatrix(DoubleMatrix2D matrix, String name) {
    method toMatrix (line 437) | public static String toMatrix(double[][] matrix, String name) {
    method toMatrix (line 441) | public static String toMatrix(int[][] matrix, String name) {
    method toVector (line 449) | private static <T> String toVector(Iterable<T> collection, String sepa...
    method toVector (line 466) | private static String toVector(int[] array, String separator) {
    method toVector (line 480) | private static String toVector(double[] array, String separator) {
    method toVector (line 494) | private static String toVector(DoubleMatrix1D array, String separator) {
    method toMatrix (line 508) | public static String toMatrix(DoubleMatrix2D matrix) {
    method toMatrix (line 526) | public static String toMatrix(double[][] matrix) {
    method toMatrix (line 549) | public static String toMatrix(int[][] matrix) {
    method toStringList (line 576) | public static String toStringList(List<String> array) {

FILE: src/java/edu/stanford/math/plex4/io/ObjReader.java
  class ObjReader (line 15) | public class ObjReader implements ObjectReader<GeometricSimplexStream> {
    method importFromFile (line 17) | public GeometricSimplexStream importFromFile(String path) {

FILE: src/java/edu/stanford/math/plex4/io/ObjectReader.java
  type ObjectReader (line 5) | public interface ObjectReader<T> {
    method importFromFile (line 6) | T importFromFile(String path) throws IOException;

FILE: src/java/edu/stanford/math/plex4/io/ObjectWriter.java
  type ObjectWriter (line 5) | public interface ObjectWriter<T> {
    method writeToFile (line 6) | void writeToFile(T object, String path) throws IOException;
    method getExtension (line 7) | String getExtension();

FILE: src/java/edu/stanford/math/plex4/io/SimplexStreamReaderWriter.java
  class SimplexStreamReaderWriter (line 13) | public class SimplexStreamReaderWriter implements ObjectReader<AbstractF...
    method SimplexStreamReaderWriter (line 16) | private SimplexStreamReaderWriter() {}
    method getInstance (line 18) | public static SimplexStreamReaderWriter getInstance() {
    method getExtension (line 22) | public String getExtension() {
    method importFromFile (line 26) | public AbstractFilteredStream<Simplex> importFromFile(String path) thr...
    method writeToFile (line 62) | public void writeToFile(AbstractFilteredStream<Simplex> object, String...

FILE: src/java/edu/stanford/math/plex4/io/Table.java
  class Table (line 18) | public class Table {
    method Table (line 30) | public Table() {
    method setTitle (line 39) | public void setTitle(String title) {
    method getTitle (line 49) | public String getTitle() {
    method addColumn (line 59) | public void addColumn(String columnHeading) {
    method setColumnHeading (line 72) | public void setColumnHeading(int column, String columnHeading) {
    method getColumnHeading (line 84) | public String getColumnHeading(int column) {
    method addRow (line 96) | public void addRow(Collection<Object> row) {
    method addRow (line 115) | public void addRow(List<String> row) {
    method addRow (line 132) | public void addRow(String[] row, boolean trimElements) {
    method getEntry (line 158) | public String getEntry(int row, int column) {
    method toString (line 170) | @Override
    method toCSVString (line 187) | public String toCSVString(String separator, boolean includeTitle, bool...
    method toPrettyString (line 226) | public String toPrettyString(String separator) {
    method padString (line 284) | private String padString(String input, int length, char padCharacter) {
    method repeatCharacter (line 304) | private String repeatCharacter(char character, int length) {

FILE: src/java/edu/stanford/math/plex4/kd/KDEuclideanMetricSpace.java
  class KDEuclideanMetricSpace (line 15) | public class KDEuclideanMetricSpace extends ObjectSearchableFiniteMetric...
    method KDEuclideanMetricSpace (line 19) | public KDEuclideanMetricSpace(double[][] dataPoints) {
    method getPoints (line 25) | public double[][] getPoints() {
    method getNearestPointIndex (line 29) | public int getNearestPointIndex(double[] queryPoint) {
    method getOpenNeighborhood (line 33) | public TIntHashSet getOpenNeighborhood(double[] queryPoint, double eps...
    method getClosedNeighborhood (line 37) | public TIntHashSet getClosedNeighborhood(double[] queryPoint, double e...
    method size (line 41) | public int size() {
    method distance (line 45) | public double distance(double[] a, double[] b) {
    method getPoint (line 49) | public double[] getPoint(int index) {
    method distance (line 53) | public double distance(int i, int j) {
    method getMaximumCoordinates (line 57) | public double[] getMaximumCoordinates() {
    method getMinimumCoordinates (line 71) | public double[] getMinimumCoordinates() {

FILE: src/java/edu/stanford/math/plex4/kd/KDNode.java
  class KDNode (line 10) | public class KDNode {
    method KDNode (line 16) | public KDNode(int index, int splitAxis) {
    method getIndex (line 23) | public int getIndex() {
    method getLeft (line 27) | public KDNode getLeft() {
    method getRight (line 31) | public KDNode getRight() {
    method getSplitAxis (line 35) | public int getSplitAxis() {
    method setLeft (line 39) | public void setLeft(KDNode node) {
    method setRight (line 43) | public void setRight(KDNode node) {

FILE: src/java/edu/stanford/math/plex4/kd/KDTree.java
  class KDTree (line 22) | public class KDTree {
    method KDTree (line 45) | public KDTree(double[][] dataPoints) {
    method construct (line 64) | private KDNode construct(List<Integer> points, int depth) {
    method getRandomSplitIndex (line 100) | private int getRandomSplitIndex(List<Integer> pointIndices) {
    method getMedianSplitIndex (line 112) | private int getMedianSplitIndex(List<Integer> pointIndices, final int ...
    method splitPoints (line 127) | private ObjectObjectPair<List<Integer>, List<Integer>> splitPoints(Lis...
    method getAxisComparator (line 150) | private Comparator<Integer> getAxisComparator(final int axis) {
    method nearestNeighborSearch (line 171) | public int nearestNeighborSearch(double[] queryPoint) {
    method nearestNeighborSearch (line 185) | private int nearestNeighborSearch(KDNode node, double[] queryPoint, in...
    method epsilonNeighborhoodSearch (line 240) | public TIntHashSet epsilonNeighborhoodSearch(double[] queryPoint, doub...
    method epsilonNeighborhoodSearch (line 256) | private void epsilonNeighborhoodSearch(KDNode node, double[] queryPoin...

FILE: src/java/edu/stanford/math/plex4/metric/impl/EuclideanMetricSpace.java
  class EuclideanMetricSpace (line 12) | public class EuclideanMetricSpace extends ObjectSearchableFiniteMetricSp...
    method EuclideanMetricSpace (line 19) | public EuclideanMetricSpace(double[][] array) {
    method distance (line 23) | @Override

FILE: src/java/edu/stanford/math/plex4/metric/impl/ExplicitMetricSpace.java
  class ExplicitMetricSpace (line 16) | public class ExplicitMetricSpace implements AbstractSearchableMetricSpac...
    method ExplicitMetricSpace (line 32) | public ExplicitMetricSpace(double[][] distanceMatrix) {
    method distance (line 36) | public double distance(int i, int j) {
    method size (line 40) | public int size() {
    method getClosedNeighborhood (line 44) | public TIntHashSet getClosedNeighborhood(Integer queryPoint, double ep...
    method getKNearestNeighbors (line 57) | public TIntHashSet getKNearestNeighbors(Integer queryPoint, int k) {
    method getNearestPointIndex (line 78) | public int getNearestPointIndex(Integer queryPoint) {
    method getOpenNeighborhood (line 96) | public TIntHashSet getOpenNeighborhood(Integer queryPoint, double epsi...
    method getPoint (line 109) | public Integer getPoint(int index) {
    method getPoints (line 113) | public Integer[] getPoints() {
    method distance (line 122) | public double distance(Integer a, Integer b) {

FILE: src/java/edu/stanford/math/plex4/metric/impl/ObjectSearchableFiniteMetricSpace.java
  class ObjectSearchableFiniteMetricSpace (line 16) | public abstract class ObjectSearchableFiniteMetricSpace<T> implements Ab...
    method ObjectSearchableFiniteMetricSpace (line 28) | public ObjectSearchableFiniteMetricSpace(T[] array) {
    method getKNearestNeighbors (line 32) | public TIntHashSet getKNearestNeighbors(T queryPoint, int k) {
    method getNearestPointIndex (line 55) | public int getNearestPointIndex(T queryPoint) {
    method getOpenNeighborhood (line 72) | public TIntHashSet getOpenNeighborhood(T queryPoint, double epsilon) {
    method getClosedNeighborhood (line 89) | public TIntHashSet getClosedNeighborhood(T queryPoint, double epsilon) {
    method distance (line 103) | public abstract double distance(T a, T b);
    method getPoint (line 105) | public T getPoint(int index) {
    method getPoints (line 109) | public T[] getPoints() {
    method distance (line 113) | public double distance(int i, int j) {
    method size (line 117) | public int size() {

FILE: src/java/edu/stanford/math/plex4/metric/impl/TruncatedPriorityQueue.java
  class TruncatedPriorityQueue (line 20) | public class TruncatedPriorityQueue<T> {
    method TruncatedPriorityQueue (line 24) | public TruncatedPriorityQueue(int k) {
    method getListOfPairs (line 33) | public List<ObjectDoublePair<T>> getListOfPairs() {
    method getIndices (line 42) | public List<T> getIndices() {
    method insert (line 66) | public void insert(T index, double value) {
    method truncate (line 103) | private void truncate() {

FILE: src/java/edu/stanford/math/plex4/metric/interfaces/AbstractIntMetricSpace.java
  type AbstractIntMetricSpace (line 11) | public interface AbstractIntMetricSpace {
    method distance (line 21) | public double distance(int i, int j);
    method size (line 28) | public int size();

FILE: src/java/edu/stanford/math/plex4/metric/interfaces/AbstractObjectMetric.java
  type AbstractObjectMetric (line 12) | public interface AbstractObjectMetric<T> {
    method distance (line 21) | public double distance(T a, T b);

FILE: src/java/edu/stanford/math/plex4/metric/interfaces/AbstractObjectMetricSpace.java
  type AbstractObjectMetricSpace (line 11) | public interface AbstractObjectMetricSpace<T> extends AbstractIntMetricS...
    method getPoint (line 19) | public T getPoint(int index);
    method getPoints (line 28) | public T[] getPoints();

FILE: src/java/edu/stanford/math/plex4/metric/interfaces/AbstractSearchableMetricSpace.java
  type AbstractSearchableMetricSpace (line 13) | public interface AbstractSearchableMetricSpace<T> extends AbstractObject...
    method getNearestPointIndex (line 22) | public int getNearestPointIndex(T queryPoint);
    method getOpenNeighborhood (line 33) | public TIntHashSet getOpenNeighborhood(T queryPoint, double epsilon);
    method getClosedNeighborhood (line 44) | public TIntHashSet getClosedNeighborhood(T queryPoint, double epsilon);
    method getKNearestNeighbors (line 53) | public TIntHashSet getKNearestNeighbors(T queryPoint, int k);

FILE: src/java/edu/stanford/math/plex4/metric/landmark/ExplicitLandmarkSelector.java
  class ExplicitLandmarkSelector (line 5) | public class ExplicitLandmarkSelector<T> extends LandmarkSelector<T> {
    method ExplicitLandmarkSelector (line 6) | public ExplicitLandmarkSelector(AbstractSearchableMetricSpace<T> metri...
    method computeLandmarkSet (line 10) | @Override

FILE: src/java/edu/stanford/math/plex4/metric/landmark/LandmarkSelector.java
  class LandmarkSelector (line 32) | public abstract class LandmarkSelector<T> implements AbstractSearchableM...
    method LandmarkSelector (line 61) | public LandmarkSelector(AbstractSearchableMetricSpace<T> metricSpace, ...
    method LandmarkSelector (line 82) | public LandmarkSelector(AbstractSearchableMetricSpace<T> metricSpace, ...
    method LandmarkSelector (line 86) | public LandmarkSelector(AbstractSearchableMetricSpace<T> metricSpace, ...
    method getLandmarkIndex (line 103) | public int getLandmarkIndex(int i) {
    method getLandmarkPoints (line 107) | public int[] getLandmarkPoints() {
    method size (line 111) | public int size() {
    method distance (line 115) | public double distance(int i, int j) {
    method distance (line 119) | public double distance(T a, T b) {
    method getPoint (line 123) | public T getPoint(int index) {
    method getUnderlyingMetricSpace (line 127) | public AbstractSearchableMetricSpace<T> getUnderlyingMetricSpace() {
    method getPoints (line 131) | public T[] getPoints() {
    method computeLandmarkSet (line 143) | protected abstract int[] computeLandmarkSet();
    method getMaxDistanceFromPointsToLandmarks (line 153) | public double getMaxDistanceFromPointsToLandmarks() {
    method toSet (line 180) | private static TIntHashSet toSet(int[] values) {
    method getClosedNeighborhood (line 190) | public TIntHashSet getClosedNeighborhood(T queryPoint, double epsilon) {
    method getOpenNeighborhood (line 201) | public TIntHashSet getOpenNeighborhood(T queryPoint, double epsilon) {
    method getKNearestNeighbors (line 212) | public TIntHashSet getKNearestNeighbors(T queryPoint, int k) {
    method getNearestPointIndex (line 236) | public int getNearestPointIndex(T queryPoint) {

FILE: src/java/edu/stanford/math/plex4/metric/landmark/MaxMinLandmarkSelector.java
  class MaxMinLandmarkSelector (line 21) | public class MaxMinLandmarkSelector<T> extends LandmarkSelector<T> {
    method MaxMinLandmarkSelector (line 32) | public MaxMinLandmarkSelector(AbstractSearchableMetricSpace<T> metricS...
    method MaxMinLandmarkSelector (line 46) | public MaxMinLandmarkSelector(AbstractSearchableMetricSpace<T> metricS...
    method computeLandmarkSet (line 52) | @Override
    method computeMinDistance (line 98) | private double computeMinDistance(int queryPointIndex, TIntHashSet exi...

FILE: src/java/edu/stanford/math/plex4/metric/landmark/RandomLandmarkSelector.java
  class RandomLandmarkSelector (line 18) | public class RandomLandmarkSelector<T> extends LandmarkSelector<T> {
    method RandomLandmarkSelector (line 27) | public RandomLandmarkSelector(AbstractSearchableMetricSpace<T> metricS...
    method computeLandmarkSet (line 31) | @Override

FILE: src/java/edu/stanford/math/plex4/metric/utility/DensityEstimation.java
  class DensityEstimation (line 5) | public class DensityEstimation {
    method performGaussianKernelDensityEstimation (line 6) | public static double[] performGaussianKernelDensityEstimation(Abstract...

FILE: src/java/edu/stanford/math/plex4/metric/utility/MetricUtility.java
  class MetricUtility (line 20) | public class MetricUtility {
    method estimateDiameter (line 32) | public static double estimateDiameter(AbstractIntMetricSpace metricSpa...
    method estimateDiameter (line 53) | public static double estimateDiameter(AbstractIntMetricSpace metricSpa...
    method computeMaxima (line 63) | public static double[] computeMaxima(AbstractObjectMetricSpace<double[...
    method computeMinima (line 84) | public static double[] computeMinima(AbstractObjectMetricSpace<double[...
    method computeCentroid (line 105) | public static double[] computeCentroid(AbstractObjectMetricSpace<doubl...
    method getAllDistances (line 121) | public static double[] getAllDistances(AbstractIntMetricSpace metricSp...
    method getKthNearestNeighborDistances (line 132) | public static <T> double[] getKthNearestNeighborDistances(AbstractSear...
    method filterByNeighborDistance (line 146) | public static <T> int[] filterByNeighborDistance(AbstractSearchableMet...

FILE: src/java/edu/stanford/math/plex4/streams/derived/DualStream.java
  class DualStream (line 29) | public class DualStream<T> implements AbstractFilteredStream<T> {
    method DualStream (line 57) | public DualStream(AbstractFilteredStream<T> forwardStream) {
    method iterator (line 65) | public Iterator<T> iterator() {
    method getFiltrationIndex (line 72) | public int getFiltrationIndex(T basisElement) {
    method getFiltrationValue (line 76) | public double getFiltrationValue(T basisElement) {
    method containsElement (line 83) | public boolean containsElement(T basisElement) {
    method getBoundary (line 92) | public T[] getBoundary(T basisElement) {
    method getBoundaryCoefficients (line 103) | public int[] getBoundaryCoefficients(T basisElement) {
    method getDimension (line 114) | public int getDimension(T basisElement) {
    method finalizeStream (line 121) | public void finalizeStream() {
    method isFinalized (line 130) | public boolean isFinalized() {
    method getSize (line 137) | public int getSize() {
    method constructCoboundaries (line 144) | private void constructCoboundaries() {
    method getMaximumFiltrationIndex (line 180) | public int getMaximumFiltrationIndex() {
    method getMinimumFiltrationIndex (line 184) | public int getMinimumFiltrationIndex() {
    method getBasisComparator (line 191) | public Comparator<T> getBasisComparator() {
    method transform (line 195) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...

FILE: src/java/edu/stanford/math/plex4/streams/derived/HomStream.java
  class HomStream (line 31) | public class HomStream<T, U> extends TensorStream<T, U> {
    method HomStream (line 39) | public HomStream(AbstractFilteredStream<T> domainStream, AbstractFilte...
    method getDimension (line 43) | @Override
    method getHomotopies (line 48) | public <R> List<IntSparseFormalSum<ObjectObjectPair<T, U>>> getHomotop...
    method getHomotopies (line 59) | public <R> List<ObjectSparseFormalSum<R, ObjectObjectPair<T, U>>> getH...
    method getHomotopiesAsDouble (line 71) | public <R extends Number> List<DoubleSparseFormalSum<ObjectObjectPair<...
    method toDoubleFormalSum (line 83) | public static <R extends Number, M> DoubleSparseFormalSum<M> toDoubleF...
    method toDoubleFormalSum (line 102) | public static <R extends Number, M> List<DoubleSparseFormalSum<M>> toD...

FILE: src/java/edu/stanford/math/plex4/streams/derived/TensorStream.java
  class TensorStream (line 30) | public class TensorStream<T, U> implements AbstractFilteredStream<Object...
    method TensorStream (line 48) | public TensorStream(AbstractFilteredStream<T> stream1, AbstractFiltere...
    method getBoundary (line 56) | public ObjectObjectPair<T, U>[] getBoundary(ObjectObjectPair<T, U> bas...
    method getBoundaryCoefficients (line 85) | public int[] getBoundaryCoefficients(ObjectObjectPair<T, U> basisEleme...
    method getDimension (line 114) | public int getDimension(ObjectObjectPair<T, U> basisElement) {
    method iterator (line 121) | public Iterator<ObjectObjectPair<T, U>> iterator() {
    method getFiltrationIndex (line 128) | public int getFiltrationIndex(ObjectObjectPair<T, U> basisElement) {
    method getFiltrationValue (line 132) | public double getFiltrationValue(ObjectObjectPair<T, U> basisElement) {
    method containsElement (line 139) | public boolean containsElement(ObjectObjectPair<T, U> basisElement) {
    method finalizeStream (line 147) | public void finalizeStream() {
    method isFinalized (line 160) | public boolean isFinalized() {
    method getSize (line 167) | public int getSize() {
    method getMaximumFiltrationIndex (line 174) | public int getMaximumFiltrationIndex() {
    method getMinimumFiltrationIndex (line 178) | public int getMinimumFiltrationIndex() {
    method getBasisComparator (line 182) | public Comparator<ObjectObjectPair<T, U>> getBasisComparator() {
    method transform (line 186) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...

FILE: src/java/edu/stanford/math/plex4/streams/derived/TruncatedStream.java
  class TruncatedStream (line 12) | public class TruncatedStream<T> implements AbstractFilteredStream<T> {
    method TruncatedStream (line 18) | public TruncatedStream(AbstractFilteredStream<T> stream, double maxFil...
    method finalizeStream (line 37) | public void finalizeStream() {
    method getBasisComparator (line 43) | public Comparator<T> getBasisComparator() {
    method getBoundary (line 47) | public T[] getBoundary(T basisElement) {
    method getBoundaryCoefficients (line 51) | public int[] getBoundaryCoefficients(T basisElement) {
    method getDimension (line 55) | public int getDimension(T basisElement) {
    method getFiltrationIndex (line 59) | public int getFiltrationIndex(T basisElement) {
    method getFiltrationValue (line 63) | public double getFiltrationValue(T basisElement) {
    method containsElement (line 70) | public boolean containsElement(T basisElement) {
    method getMaximumFiltrationIndex (line 75) | public int getMaximumFiltrationIndex() {
    method getMinimumFiltrationIndex (line 79) | public int getMinimumFiltrationIndex() {
    method getSize (line 83) | public int getSize() {
    method isFinalized (line 87) | public boolean isFinalized() {
    method transform (line 91) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...
    method iterator (line 95) | public Iterator<T> iterator() {

FILE: src/java/edu/stanford/math/plex4/streams/filter/EccentricityFilterFunction.java
  class EccentricityFilterFunction (line 5) | public class EccentricityFilterFunction implements IntFilterFunction {
    method EccentricityFilterFunction (line 10) | public EccentricityFilterFunction(AbstractIntMetricSpace metricSpace) {
    method evaluate (line 40) | public double evaluate(int point) {
    method getMaxValue (line 44) | public double getMaxValue() {
    method getMinValue (line 48) | public double getMinValue() {
    method getValues (line 52) | public double[] getValues() {

FILE: src/java/edu/stanford/math/plex4/streams/filter/ExplicitIntFilterFunction.java
  class ExplicitIntFilterFunction (line 4) | public class ExplicitIntFilterFunction implements IntFilterFunction {
    method ExplicitIntFilterFunction (line 9) | public ExplicitIntFilterFunction(double[] values) {
    method evaluate (line 23) | public double evaluate(int point) {
    method getMaxValue (line 27) | public double getMaxValue() {
    method getMinValue (line 31) | public double getMinValue() {
    method getValues (line 35) | public double[] getValues() {

FILE: src/java/edu/stanford/math/plex4/streams/filter/FilterFunction.java
  type FilterFunction (line 3) | public interface FilterFunction<T> {
    method evaluate (line 4) | double evaluate(T point);

FILE: src/java/edu/stanford/math/plex4/streams/filter/IntFilterFunction.java
  type IntFilterFunction (line 3) | public interface IntFilterFunction {
    method evaluate (line 4) | double evaluate(int point);
    method getMaxValue (line 6) | double getMaxValue();
    method getMinValue (line 7) | double getMinValue();
    method getValues (line 9) | double[] getValues();

FILE: src/java/edu/stanford/math/plex4/streams/filter/KernelDensityFilterFunction.java
  class KernelDensityFilterFunction (line 6) | public class KernelDensityFilterFunction implements IntFilterFunction {
    method KernelDensityFilterFunction (line 12) | public KernelDensityFilterFunction(AbstractIntMetricSpace metricSpace,...
    method evaluate (line 16) | public double evaluate(int point) {
    method getMaxValue (line 20) | public double getMaxValue() {
    method getMinValue (line 27) | public double getMinValue() {
    method computeMaxMinValues (line 34) | private void computeMaxMinValues() {
    method getValues (line 48) | public double[] getValues() {

FILE: src/java/edu/stanford/math/plex4/streams/filter/MaxSimplicialFilterFunction.java
  class MaxSimplicialFilterFunction (line 5) | public class MaxSimplicialFilterFunction implements FilterFunction<Simpl...
    method MaxSimplicialFilterFunction (line 7) | public MaxSimplicialFilterFunction(IntFilterFunction intFilterFunction) {
    method evaluate (line 11) | public double evaluate(Simplex simplex) {

FILE: src/java/edu/stanford/math/plex4/streams/filter/MinSimplicialFilterFunction.java
  class MinSimplicialFilterFunction (line 5) | public class MinSimplicialFilterFunction implements FilterFunction<Simpl...
    method MinSimplicialFilterFunction (line 7) | public MinSimplicialFilterFunction(IntFilterFunction intFilterFunction) {
    method evaluate (line 11) | public double evaluate(Simplex simplex) {

FILE: src/java/edu/stanford/math/plex4/streams/filter/RandomProjectionFilterFunction.java
  class RandomProjectionFilterFunction (line 7) | public class RandomProjectionFilterFunction implements IntFilterFunction {
    method RandomProjectionFilterFunction (line 14) | public RandomProjectionFilterFunction(EuclideanMetricSpace metricSpace) {
    method RandomProjectionFilterFunction (line 18) | public RandomProjectionFilterFunction(double[][] points) {
    method evaluate (line 37) | public double evaluate(int point) {
    method getMaxValue (line 41) | public double getMaxValue() {
    method getMinValue (line 45) | public double getMinValue() {
    method getRangeMax (line 49) | public int getRangeMax() {
    method getValues (line 53) | public double[] getValues() {

FILE: src/java/edu/stanford/math/plex4/streams/impl/ExplicitCellStream.java
  class ExplicitCellStream (line 18) | public class ExplicitCellStream extends ExplicitStream<Cell> {
    method ExplicitCellStream (line 28) | public ExplicitCellStream() {
    method ExplicitCellStream (line 32) | public ExplicitCellStream(double maxFiltrationValue) {
    method addNewVertex (line 41) | public int addNewVertex() {
    method attachNewCellToPoint (line 55) | public int attachNewCellToPoint(int dimension, int pointIndex) {
    method attachNewCell (line 70) | public int attachNewCell(int dimension, int[] boundaryIndices) {
    method attachNewCell (line 85) | public int attachNewCell(int dimension, int[] boundaryIndices, int[] b...
    method addElement (line 92) | @Override
    method getCellsByIds (line 103) | private Collection<Cell> getCellsByIds(int[] cellIds) {

FILE: src/java/edu/stanford/math/plex4/streams/impl/ExplicitSimplexStream.java
  class ExplicitSimplexStream (line 15) | public class ExplicitSimplexStream extends ExplicitStream<Simplex> {
    method ExplicitSimplexStream (line 23) | public ExplicitSimplexStream(Comparator<Simplex> comparator) {
    method ExplicitSimplexStream (line 27) | public ExplicitSimplexStream(Comparator<Simplex> comparator, double ma...
    method ExplicitSimplexStream (line 34) | public ExplicitSimplexStream() {
    method ExplicitSimplexStream (line 38) | public ExplicitSimplexStream(double maxFiltrationValue) {
    method addVertex (line 48) | public void addVertex(int index) {
    method addVertex (line 59) | public void addVertex(int index, double filtrationValue) {
    method addElement (line 68) | public void addElement(int[] vertices) {
    method addElement (line 79) | public void addElement(int[] vertices, double filtrationValue) {
    method removeElementIfPresent (line 83) | public boolean removeElementIfPresent(int[] vertices) {

FILE: src/java/edu/stanford/math/plex4/streams/impl/ExplicitStream.java
  class ExplicitStream (line 29) | public class ExplicitStream<T extends PrimitiveBasisElement> extends Pri...
    method ExplicitStream (line 41) | public ExplicitStream(Comparator<T> comparator) {
    method ExplicitStream (line 45) | public ExplicitStream(Comparator<T> comparator, double maxFiltrationVa...
    method ExplicitStream (line 57) | public ExplicitStream(AbstractFilteredStream<T> stream, Comparator<T> ...
    method addAllElements (line 67) | public void addAllElements(AbstractFilteredStream<T> stream) {
    method addElement (line 79) | public void addElement(T basisElement, double filtrationValue) {
    method removeElementIfPresent (line 100) | public boolean removeElementIfPresent(T basisElement) {
    method containsElement (line 115) | public boolean containsElement(T basisElement) {
    method constructComplex (line 119) | @Override
    method ensureAllFaces (line 128) | public void ensureAllFaces() {
    method transform (line 171) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...
    method getFiltrationValue (line 180) | public double getFiltrationValue(T basisElement) {

FILE: src/java/edu/stanford/math/plex4/streams/impl/FlagComplexStream.java
  class FlagComplexStream (line 46) | public abstract class FlagComplexStream extends PrimitiveStream<Simplex> {
    method FlagComplexStream (line 73) | public FlagComplexStream(int maxAllowableDimension, FiltrationConverte...
    method FlagComplexStream (line 79) | public FlagComplexStream(int maxAllowableDimension, FiltrationConverte...
    method FlagComplexStream (line 97) | public FlagComplexStream(int maxAllowableDimension, FiltrationConverte...
    method constructEdges (line 111) | protected abstract UndirectedWeightedListGraph constructEdges();
    method getNeighborhoodGraph (line 119) | public UndirectedWeightedListGraph getNeighborhoodGraph() {
    method getFiltrationValue (line 123) | public double getFiltrationValue(Simplex simplex) {
    method getConverter (line 132) | public FiltrationConverter getConverter() {
    method transform (line 145) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...
    method constructComplex (line 149) | @Override
    method incrementalExpansion (line 166) | protected void incrementalExpansion(UndirectedWeightedListGraph G, int...
    method addCofaces (line 191) | protected void addCofaces(UndirectedWeightedListGraph G, int k, Simple...

FILE: src/java/edu/stanford/math/plex4/streams/impl/FlexibleVietorisRipsStream.java
  class FlexibleVietorisRipsStream (line 32) | public class FlexibleVietorisRipsStream<T> extends FlagComplexStream {
    method FlexibleVietorisRipsStream (line 56) | public FlexibleVietorisRipsStream(AbstractSearchableMetricSpace<T> met...
    method FlexibleVietorisRipsStream (line 63) | public FlexibleVietorisRipsStream(AbstractSearchableMetricSpace<T> met...
    method FlexibleVietorisRipsStream (line 71) | public FlexibleVietorisRipsStream(AbstractSearchableMetricSpace<T> met...
    method constructEdges (line 79) | @Override

FILE: src/java/edu/stanford/math/plex4/streams/impl/GeometricSimplexStream.java
  class GeometricSimplexStream (line 27) | public class GeometricSimplexStream implements AbstractFilteredStream<Si...
    method GeometricSimplexStream (line 45) | public GeometricSimplexStream(AbstractFilteredStream<Simplex> stream, ...
    method GeometricSimplexStream (line 59) | public GeometricSimplexStream(AbstractFilteredStream<Simplex> stream, ...
    method finalizeStream (line 69) | public void finalizeStream() {
    method getFiltrationIndex (line 76) | public int getFiltrationIndex(Simplex basisElement) {
    method containsElement (line 83) | public boolean containsElement(Simplex basisElement) {
    method isFinalized (line 91) | public boolean isFinalized() {
    method iterator (line 98) | public Iterator<Simplex> iterator() {
    method getPoint (line 105) | public double[] getPoint(int index) {
    method size (line 112) | public int size() {
    method distance (line 119) | public double distance(int i, int j) {
    method distance (line 126) | public double distance(double[] a, double[] b) {
    method getBoundary (line 133) | public Simplex[] getBoundary(Simplex simplex) {
    method getBoundaryCoefficients (line 140) | public int[] getBoundaryCoefficients(Simplex simplex) {
    method getDimension (line 147) | public int getDimension(Simplex element) {
    method getPoints (line 154) | public double[][] getPoints() {
    method getSize (line 161) | public int getSize() {
    method getMaximumFiltrationIndex (line 168) | public int getMaximumFiltrationIndex() {
    method getMinimumFiltrationIndex (line 172) | public int getMinimumFiltrationIndex() {
    method getBasisComparator (line 179) | public Comparator<Simplex> getBasisComparator() {
    method transform (line 183) | public <G> PersistenceInvariantDescriptor<Interval<Double>, G> transfo...
    method getFiltrationValue (line 187) | public double getFiltrationValue(Simplex basisElement) {

FILE: src/java/edu/stanford/math/plex4/streams/impl/LazyWitnessStream.java
  class LazyWitnessStream (line 36) | public class LazyWitnessStream<T> extends FlagComplexStream {
    method LazyWitnessStream (line 86) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method LazyWitnessStream (line 100) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method LazyWitnessStream (line 105) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method LazyWitnessStream (line 119) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method LazyWitnessStream (line 126) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method LazyWitnessStream (line 139) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method LazyWitnessStream (line 143) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method LazyWitnessStream (line 157) | public LazyWitnessStream(AbstractSearchableMetricSpace<T> metricSpace,...
    method setPlex3Compatbility (line 162) | public void setPlex3Compatbility(boolean value) {
    method getDefaultNuValue (line 166) | public static int getDefaultNuValue() {
    method getAssociatedSimplices (line 179) | public List<Simplex> getAssociatedSimplices(int witness) {
    method constructEdges (line 191) | @Override
    method getWitnessAndDistance (line 280) | protected IntDoublePair getWitnessAndDistance(int... landmarkIndices) {
    method contains (line 332) | protected static boolean contains(int[] array, int value) {
    method updateWitnessInformationInternalIndices (line 342) | protected void updateWitnessInformationInternalIndices(int n_star, dou...
    method updateWitnessInformation (line 346) | protected void updateWitnessInformation(int n_star, double e_ij, int.....
    method isWitness (line 359) | protected boolean isWitness(int x, Simplex simplex) {
    method isWitness (line 363) | protected boolean isWitness(int x, int[] externalIndices) {
    method getAllWitnesses (line 371) | protected TIntHashSet getAllWitnesses(fi

[
  {
    "path": ".classpath",
    "chars": 981,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<classpath>\n\t<classpathentry kind=\"src\" path=\"src/bsh\"/>\n\t<classpathentry kind=\"s"
  },
  {
    "path": ".gitignore",
    "chars": 82,
    "preview": "*.class\n\n# Package Files #\n*.jar\n*.war\n*.ear\n/bin/\n\n# Mac system files\n*.DS_Store\n"
  },
  {
    "path": ".project",
    "chars": 554,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<projectDescription>\r\n\t<name>javaplex</name>\r\n\t<comment></comment>\r\n\t<projects>\r"
  },
  {
    "path": ".settings/org.eclipse.jdt.core.prefs",
    "chars": 22622,
    "preview": "#Tue Jul 06 16:52:58 PDT 2010\r\neclipse.preferences.version=1\r\norg.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=en"
  },
  {
    "path": ".settings/org.eclipse.jdt.ui.prefs",
    "chars": 120,
    "preview": "#Tue Jul 06 16:52:58 PDT 2010\r\neclipse.preferences.version=1\r\nformatter_profile=_Andrew\r\nformatter_settings_version=11\r\n"
  },
  {
    "path": ".travis.yml",
    "chars": 15,
    "preview": "language: java\n"
  },
  {
    "path": "LICENSE.md",
    "chars": 1527,
    "preview": "Copyright (c) 2014, Henry Adams, Mikael Vejdemo-Johansson, Andrew Tausz\nAll rights reserved.\n\nRedistribution and use in "
  },
  {
    "path": "README.md",
    "chars": 3320,
    "preview": "# JavaPlex\n\n## Persistent Homology and Topological Data Analysis Library \n\n\nThe `JavaPlex` library implements persistent"
  },
  {
    "path": "build/processing/javaplex/library.properties",
    "chars": 235,
    "preview": "name=javaPlex\nauthorList=Andrew Tausz and Mikael Vejdemo-Johansson and Henry Adams\nurl=http://code.google.com/p/javaplex"
  },
  {
    "path": "build.number",
    "chars": 83,
    "preview": "#Build Number for ANT. Do not edit!\n#Sun Jul 15 19:57:53 MDT 2018\nbuild.number=102\n"
  },
  {
    "path": "build.xml",
    "chars": 9457,
    "preview": "<?xml version=\"1.0\" ?>\n\n<project name=\"javaplex\" default=\"default\" basedir=\".\">\n\t<property name=\"version.num\" value=\"4.3"
  },
  {
    "path": "data/natural_images/readme_natural_images.txt",
    "chars": 1899,
    "preview": "A natural image is a photograph. Consider natural images which contain a greyscale value at each pixel. In the paper \"On"
  },
  {
    "path": "data/point_clouds/circle.txt",
    "chars": 1928,
    "preview": "0,1,1\n0.125333233564304,0.992114701314478,1\n0.248689887164855,0.968583161128631,1\n0.368124552684678,0.929776485888251,1\n"
  },
  {
    "path": "data/point_clouds/cube.txt",
    "chars": 48,
    "preview": "0,0,0\n0,0,1\n0,1,0\n0,1,1\n1,0,0\n1,0,1\n1,1,0\n1,1,1\n"
  },
  {
    "path": "data/point_clouds/cylinder.txt",
    "chars": 15429,
    "preview": "1.98155906437293,1.01389735228371,9.91560618858784\n9.08504984057864,7.88311772218694,7.3735861806199\n9.18819705140907,7."
  },
  {
    "path": "data/point_clouds/octahedron.txt",
    "chars": 39,
    "preview": "0,0,1\n0,0,-1\n0,1,0\n0,-1,0\n1,0,0\n-1,0,0\n"
  },
  {
    "path": "data/point_clouds/sphere_rnd.txt",
    "chars": 11124,
    "preview": "0.0773054454995878,0.836334266051908,0.542741986143994\n-0.374781006964731,-0.880579478663034,0.29003271983699\n0.50978558"
  },
  {
    "path": "data/point_clouds/torus.txt",
    "chars": 16109,
    "preview": "-0.714320398612351,-1.90692591611384,-0.267078203651368\n0.880281797557814,3.78434362937461,-0.464874124438126\n1.04102781"
  },
  {
    "path": "doc_includes/overview.htm",
    "chars": 76,
    "preview": "<html>\n<head>\n<title>Plex in Java</title>\n</head>\n<body>\n\n\n\n\n</body></html>\n"
  },
  {
    "path": "doc_includes/overview_plex3.htm",
    "chars": 28718,
    "preview": "<html>\n<head>\n<title>Plex in Java</title>\n</head>\n<body>\n\n<!--  \n$Id: overview.htm,v 1.5 2008/09/25 02:30:23 hsexton Exp"
  },
  {
    "path": "doc_includes/update_mime_types.sh",
    "chars": 628,
    "preview": "#!/bin/sh\n\nsvn propset svn:mime-type text/html -R *.html\nsvn propset svn:mime-type text/html -R */*.html\nsvn propset svn"
  },
  {
    "path": "reports/javaplex_tutorial/cleanup.sh",
    "chars": 188,
    "preview": "#!/bin/bash\n\nrm javaplex_tutorial.aux\nrm javaplex_tutorial.blg\nrm javaplex_tutorial.log\nrm javaplex_tutorial.out\nrm java"
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.aux",
    "chars": 10943,
    "preview": "\\relax \n\\providecommand\\hyper@newdestlabel[2]{}\n\\providecommand\\HyperFirstAtBeginDocument{\\AtBeginDocument}\n\\HyperFirstA"
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.bbl",
    "chars": 5394,
    "preview": "\\begin{thebibliography}{21}\n\\providecommand{\\natexlab}[1]{#1}\n\\providecommand{\\url}[1]{\\texttt{#1}}\n\\expandafter\\ifx\\csn"
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.bib",
    "chars": 5113,
    "preview": "@article{Adamaszek2013,\n  title={Clique complexes and graph powers},\n  author={Adamaszek, Micha{\\l}},\n  journal={Israel "
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.blg",
    "chars": 923,
    "preview": "This is BibTeX, Version 0.99d (TeX Live 2017)\nCapacity: max_strings=100000, hash_size=100000, hash_prime=85009\nThe top-l"
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.log",
    "chars": 32626,
    "preview": "This is pdfTeX, Version 3.14159265-2.6-1.40.18 (TeX Live 2017) (preloaded format=pdflatex 2017.5.23)  15 JUL 2018 19:49\n"
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.out",
    "chars": 2543,
    "preview": "\\BOOKMARK [1][-]{section.1}{1. Introduction}{}% 1\n\\BOOKMARK [2][-]{subsection.1.1}{1.1. Javaplex}{section.1}% 2\n\\BOOKMAR"
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.tex",
    "chars": 108347,
    "preview": "\\documentclass[amscd, amssymb, verbatim]{amsart}[12pt]\n\n\\usepackage{fullpage}\n\\usepackage{amssymb}\n\\usepackage{latexsym}"
  },
  {
    "path": "reports/javaplex_tutorial/javaplex_tutorial.toc",
    "chars": 3213,
    "preview": "\\contentsline {section}{\\tocsection {}{1}{Introduction}}{2}{section.1}\n\\contentsline {subsection}{\\tocsubsection {}{1.1}"
  },
  {
    "path": "src/bsh/desktop.bsh",
    "chars": 5637,
    "preview": "/**\n * Start the BeanShell GUI desktop in a JFrame.  A starter workspace is created\n * and added to the desktop. \n *\n * "
  },
  {
    "path": "src/bsh/getBshPrompt.bsh",
    "chars": 572,
    "preview": "/**\n\tGet the value to display for the bsh interactive prompt.\n\tThis command checks for the variable bsh.prompt and uses "
  },
  {
    "path": "src/bsh/makeListener.bsh",
    "chars": 1598,
    "preview": "/**\n * Creates an interpreter loop and returns it.\n *\n * @return this (the workspace scripted object for allowing access"
  },
  {
    "path": "src/bsh/makeWorkspace.bsh",
    "chars": 4055,
    "preview": "/**\n * Creates a JConsole in a JInternalFrame and adds it to the desktop \n *\n * @return this (the workspace scripted obj"
  },
  {
    "path": "src/bsh/printBanner.bsh",
    "chars": 921,
    "preview": "/**\n\tPrint the BeanShell banner (version and author line) - GUI or non GUI.\n\n\t@author Daniel Leuck\n\t@author Harlan Sexto"
  },
  {
    "path": "src/cpp/Makefile",
    "chars": 263,
    "preview": "build:\n\tR CMD build --configure-args='--with-jplex=/afs/ir.stanford.edu/users/c/h/chakj/plex3/jplex.jar' PLEX3\ncheck:\n\tR"
  },
  {
    "path": "src/cpp/PLEX3/DESCRIPTION",
    "chars": 282,
    "preview": "Package: PLEX3\nType: Package\nTitle: R Interface for the PLEX3 Library\nVersion: 2.4.0 \nDate: 2008-02-05\nAuthor: John Chak"
  },
  {
    "path": "src/cpp/PLEX3/R/plex.R",
    "chars": 5302,
    "preview": "\n`as.internal.distance.matrix` <- function(dmatrix)\n{\n\tpdata.handle = .Call(\"make_internal_distance_array\", as.matrix(dm"
  },
  {
    "path": "src/cpp/PLEX3/R/zzz.R",
    "chars": 121,
    "preview": "`.First.lib` <-\nfunction(libname,pkgname)\n{\n\tlibrary.dynam(\"PLEX3\", pkgname, libname)\n\t.Call(\"init_java\", jplex.path)\n}\n"
  },
  {
    "path": "src/cpp/PLEX3/autom4te.cache/output.0",
    "chars": 164339,
    "preview": "@%:@! /bin/sh\n@%:@ Guess values for system-dependent variables and create Makefiles.\n@%:@ Generated by GNU Autoconf 2.61"
  },
  {
    "path": "src/cpp/PLEX3/autom4te.cache/requests",
    "chars": 2661,
    "preview": "# This file was generated by Autom4te Wed Mar 19 22:03:23 PDT 2008.\n# It contains the lists of macros which have been tr"
  },
  {
    "path": "src/cpp/PLEX3/autom4te.cache/traces.0",
    "chars": 21395,
    "preview": "m4trace:configure.ac:1: -1- AC_INIT([src/rbind_jni.cpp])\nm4trace:configure.ac:1: -1- m4_pattern_forbid([^_?A[CHUM]_])\nm4"
  },
  {
    "path": "src/cpp/PLEX3/config.guess",
    "chars": 44892,
    "preview": "#! /bin/sh\n# Attempt to guess a canonical system name.\n#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,"
  },
  {
    "path": "src/cpp/PLEX3/config.status",
    "chars": 22390,
    "preview": "#! /bin/bash\n# Generated by configure.\n# Run this file to recreate the current configuration.\n# Compiler output produced"
  },
  {
    "path": "src/cpp/PLEX3/config.sub",
    "chars": 33387,
    "preview": "#! /bin/sh\n# Configuration validation subroutine script.\n#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 199"
  },
  {
    "path": "src/cpp/PLEX3/configure",
    "chars": 163863,
    "preview": "#! /bin/sh\n# Guess values for system-dependent variables and create Makefiles.\n# Generated by GNU Autoconf 2.61.\n#\n# Cop"
  },
  {
    "path": "src/cpp/PLEX3/configure.ac",
    "chars": 1731,
    "preview": "AC_INIT([src/rbind_jni.cpp])\n\nAC_PROG_CC\nAC_PROG_CXX\n\nAC_PROG_INSTALL\n\nAC_PROG_GCC_TRADITIONAL\nAC_FUNC_MEMCMP\nAC_FUNC_MA"
  },
  {
    "path": "src/cpp/PLEX3/install-sh",
    "chars": 13620,
    "preview": "#!/bin/sh\n# install - install a program, script, or datafile\n\nscriptversion=2006-12-25.00\n\n# This originates from X11R5 "
  },
  {
    "path": "src/cpp/PLEX3/man/rips.stream.Rd",
    "chars": 797,
    "preview": "\\name{rips.stream}\n\\alias{rips.stream}\n\\title{Rips Stream}\n\\description{\n\tConstruct a Rips Stream from either a distance"
  },
  {
    "path": "src/cpp/PLEX3/src/Makevars.in",
    "chars": 40,
    "preview": "PKG_CPPFLAGS=@CPPFLAGS@\nPKG_LIBS=@LIBS@\n"
  },
  {
    "path": "src/cpp/PLEX3/src/rbind_jni.cpp",
    "chars": 16124,
    "preview": "#include <cstdio>\n#include <cstdlib>\n#include <cmath>\n\n#include <iostream>\n#include <string>\n\n#include <map>\n\n#include <"
  },
  {
    "path": "src/java/bsh/JPlex.java",
    "chars": 1957,
    "preview": "package bsh;\r\n\r\n// \r\n//  JPlex.java\r\n// \r\n//  **************************************************************************"
  },
  {
    "path": "src/java/bsh/JTerm.java",
    "chars": 1787,
    "preview": "package bsh;\r\n\r\n// \r\n//  JTerm.java\r\n// \r\n//  **************************************************************************"
  },
  {
    "path": "src/java/bsh/PlexInterpreter.java",
    "chars": 3248,
    "preview": "// \r\n//  PlexInterpreter.java\r\n// \r\n//  ***************************************************************************\r\n// "
  },
  {
    "path": "src/java/bsh/PlexReader.java",
    "chars": 16288,
    "preview": "// \r\n//  PlexReader.java\r\n// \r\n//  ***************************************************************************\r\n// \r\n// "
  },
  {
    "path": "src/java/bsh/commands/log.java",
    "chars": 2676,
    "preview": "// \n//  log.java\n// \n//  ***************************************************************************\n// \n//  Copyright 2"
  },
  {
    "path": "src/java/bsh/commands/setLogging.java",
    "chars": 1874,
    "preview": "// \n//  setLogging.java\n// \n//  ***************************************************************************\n// \n//  Copy"
  },
  {
    "path": "src/java/edu/stanford/math/clustering/DisjointSetSystem.java",
    "chars": 835,
    "preview": "package edu.stanford.math.clustering;\n\npublic class DisjointSetSystem {\n\tprotected int[] parents;\n\tprotected int[] ranks"
  },
  {
    "path": "src/java/edu/stanford/math/clustering/HierarchicalClustering.java",
    "chars": 2552,
    "preview": "package edu.stanford.math.clustering;\n\nimport java.util.ArrayList;\nimport java.util.HashMap;\nimport java.util.HashSet;\ni"
  },
  {
    "path": "src/java/edu/stanford/math/clustering/LinkageTree.java",
    "chars": 135,
    "preview": "package edu.stanford.math.clustering;\n\npublic class LinkageTree {\n\tprotected double[] mergeDistances;\n\tprotected int[][]"
  },
  {
    "path": "src/java/edu/stanford/math/clustering/SingleLinkageClustering.java",
    "chars": 1722,
    "preview": "package edu.stanford.math.clustering;\n\nimport edu.stanford.math.plex4.metric.interfaces.AbstractIntMetricSpace;\n\npublic "
  },
  {
    "path": "src/java/edu/stanford/math/mapper/BoundedIntervalCover.java",
    "chars": 1038,
    "preview": "package edu.stanford.math.mapper;\n\nimport java.util.ArrayList;\nimport java.util.Iterator;\nimport java.util.List;\n\nimport"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/FilterFunctionUtility.java",
    "chars": 77,
    "preview": "package edu.stanford.math.mapper;\n\n\npublic class FilterFunctionUtility {\n\t\n}\n"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/FiniteMetricSpaceCover.java",
    "chars": 653,
    "preview": "package edu.stanford.math.mapper;\n\nimport edu.stanford.math.plex4.metric.interfaces.AbstractIntMetricSpace;\nimport edu.s"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/HistogramCreator.java",
    "chars": 3524,
    "preview": "package edu.stanford.math.mapper;\n\npublic class HistogramCreator {\n\tprotected final double[] values;\n\tprotected final in"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/MapperPipeline.java",
    "chars": 3214,
    "preview": "package edu.stanford.math.mapper;\n\nimport edu.stanford.math.clustering.DisjointSetSystem;\nimport edu.stanford.math.clust"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/MapperSpecifier.java",
    "chars": 554,
    "preview": "package edu.stanford.math.mapper;\n\npublic class MapperSpecifier {\n\tdouble overlap = 0.2;\n\tint numIntervals = 40;\n\tint nu"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/MetricUtility.java",
    "chars": 753,
    "preview": "package edu.stanford.math.mapper;\n\nimport edu.stanford.math.plex4.metric.interfaces.AbstractIntMetricSpace;\nimport gnu.t"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/RangeCoverUtility.java",
    "chars": 415,
    "preview": "package edu.stanford.math.mapper;\n\nimport edu.stanford.math.plex4.homology.barcodes.Interval;\nimport edu.stanford.math.p"
  },
  {
    "path": "src/java/edu/stanford/math/mapper/SetCover1D.java",
    "chars": 1504,
    "preview": "package edu.stanford.math.mapper;\n\nimport edu.stanford.math.plex4.homology.barcodes.Interval;\nimport edu.stanford.math.p"
  },
  {
    "path": "src/java/edu/stanford/math/plex/BCPlot.java",
    "chars": 29175,
    "preview": "package edu.stanford.math.plex;\n\nimport java.awt.BorderLayout;\nimport java.awt.Color;\nimport java.awt.Dimension;\nimport "
  },
  {
    "path": "src/java/edu/stanford/math/plex/CRC.java",
    "chars": 30325,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * The <code>CRC</code> class provides good hash methods for int/long and string"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Chain.java",
    "chars": 14326,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.util.HashMap;\r\nimport java.util.Iterator;\r\nimport java.util.List;\r\nimport"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Cone.java",
    "chars": 2110,
    "preview": "package edu.stanford.math.plex;\nimport java.util.Collections;\nimport java.util.HashMap;\nimport java.util.Iterator;\nimpor"
  },
  {
    "path": "src/java/edu/stanford/math/plex/DiscreteSpace.java",
    "chars": 768,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * The <code>DiscreteSpace</code> class implements a finite discrete metric\r\n * "
  },
  {
    "path": "src/java/edu/stanford/math/plex/DistanceData.java",
    "chars": 865,
    "preview": "package edu.stanford.math.plex;\n\n/**\n * The <code>DistanceData</code> class is the simplest implementation\n * of NSpace."
  },
  {
    "path": "src/java/edu/stanford/math/plex/EuclideanArrayData.java",
    "chars": 6150,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.util.Random;\r\n\r\n/**\r\n * The <code>EuclideanArrayData</code> class is the "
  },
  {
    "path": "src/java/edu/stanford/math/plex/ExplicitStream.java",
    "chars": 32731,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.util.Arrays;\r\nimport java.util.HashMap;\r\nimport java.util.HashSet;\r\nimpor"
  },
  {
    "path": "src/java/edu/stanford/math/plex/LazyWitnessStream.java",
    "chars": 14020,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport static edu.stanford.math.plex.RipsStream.all_edges_present;\r\nimport static edu"
  },
  {
    "path": "src/java/edu/stanford/math/plex/MappedBufferData.java",
    "chars": 11158,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.io.File;\r\nimport java.io.FileOutputStream;\r\nimport java.io.RandomAccessFi"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Packed2Simplex.java",
    "chars": 7679,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * <p>The <code>Packed2Simplex</code> class implements the abstract class\r\n * <c"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Packed4Simplex.java",
    "chars": 8577,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * <p>The <code>Packed4Simplex</code> class implements the abstract class\r\n * <c"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Packed6Simplex.java",
    "chars": 10614,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * <p>The <code>Packed6Simplex</code> class implements the abstract class\r\n * <c"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Packed8Simplex.java",
    "chars": 13127,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * <p>The <code>Packed8Simplex</code> class implements the abstract class\r\n * <c"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Persistence.java",
    "chars": 7291,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.Arrays;\r\nimport java.util.Iterator;\r\n\r\n"
  },
  {
    "path": "src/java/edu/stanford/math/plex/PersistenceBasis.java",
    "chars": 19498,
    "preview": "package edu.stanford.math.plex;\n\nimport java.util.Arrays;\nimport java.util.Iterator;\nimport java.util.LinkedHashMap;\nimp"
  },
  {
    "path": "src/java/edu/stanford/math/plex/PersistenceBasisInterval.java",
    "chars": 8771,
    "preview": "package edu.stanford.math.plex;\n\n/**\n * <code>PersistenceBasisInterval</code> instances encode a dimension and a\n * dura"
  },
  {
    "path": "src/java/edu/stanford/math/plex/PersistenceInterval.java",
    "chars": 7237,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * <code>PersistenceInterval</code> instances encode a dimension and a\r\n * durat"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Plex.java",
    "chars": 37221,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.io.File;\r\nimport java.io.FileInputStream;\r\nimport java.io.IOException;\r\ni"
  },
  {
    "path": "src/java/edu/stanford/math/plex/PlexMessageWindow.java",
    "chars": 2186,
    "preview": "package edu.stanford.math.plex;\r\nimport java.awt.BorderLayout;\r\n\r\nimport javax.swing.JFrame;\r\nimport javax.swing.JScroll"
  },
  {
    "path": "src/java/edu/stanford/math/plex/PlexSort.java",
    "chars": 13394,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * The <code>PlexSort</code> class provides a sorting routine that I'd prefer\r\n "
  },
  {
    "path": "src/java/edu/stanford/math/plex/PointData.java",
    "chars": 6151,
    "preview": "package edu.stanford.math.plex;\r\nimport java.util.Arrays;\r\nimport java.util.Iterator;\r\nimport java.util.Random;\r\n\r\n/**\r\n"
  },
  {
    "path": "src/java/edu/stanford/math/plex/RDirectBufferData.java",
    "chars": 1642,
    "preview": "package edu.stanford.math.plex;\nimport java.nio.ByteBuffer;\nimport java.nio.ByteOrder;\nimport java.nio.DoubleBuffer;\n\n\n/"
  },
  {
    "path": "src/java/edu/stanford/math/plex/RipsStream.java",
    "chars": 17441,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport static edu.stanford.math.plex.WitnessStream.HUGE;\r\n\r\nimport java.util.ArrayLis"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Simplex.java",
    "chars": 20186,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * A <code>Simplex</code> is the basic unit for simplicial homology\r\n * calculat"
  },
  {
    "path": "src/java/edu/stanford/math/plex/SimplexFaceIterator.java",
    "chars": 5483,
    "preview": "package edu.stanford.math.plex;\r\n\r\n/**\r\n * The <code>SimplexFaceIterator</code> class.\r\n *\r\n * <p>A <code>SimplexFaceIte"
  },
  {
    "path": "src/java/edu/stanford/math/plex/SimplexStream.java",
    "chars": 19021,
    "preview": "\r\npackage edu.stanford.math.plex;\r\n\r\nimport java.util.Iterator;\r\nimport java.util.NoSuchElementException;\r\n\r\n/**\r\n * An "
  },
  {
    "path": "src/java/edu/stanford/math/plex/SimplexTable.java",
    "chars": 9264,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.util.Iterator;\r\nimport java.util.NoSuchElementException;\r\n\r\n/**\r\n * A <co"
  },
  {
    "path": "src/java/edu/stanford/math/plex/TmpStream.java",
    "chars": 7391,
    "preview": "\r\npackage edu.stanford.math.plex;\r\n\r\nimport java.util.Iterator;\r\nimport java.util.NoSuchElementException;\r\n\r\n/**\r\n * The"
  },
  {
    "path": "src/java/edu/stanford/math/plex/Torus.java",
    "chars": 4532,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport static java.lang.Math.PI;\r\nimport static java.lang.Math.cos;\r\nimport static ja"
  },
  {
    "path": "src/java/edu/stanford/math/plex/WitnessStream.java",
    "chars": 20255,
    "preview": "package edu.stanford.math.plex;\r\n\r\nimport java.util.Arrays;\r\nimport java.util.HashSet;\r\nimport java.util.Iterator;\r\nimpo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/api/FilteredStreamInterface.java",
    "chars": 5801,
    "preview": "package edu.stanford.math.plex4.api;\r\n\r\nimport edu.stanford.math.plex.EuclideanArrayData;\r\nimport edu.stanford.math.plex"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/api/PersistenceAlgorithmInterface.java",
    "chars": 11401,
    "preview": "package edu.stanford.math.plex4.api;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.List;\r\n\r\nimport org.apache.commons"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/api/Plex4.java",
    "chars": 21310,
    "preview": "package edu.stanford.math.plex4.api;\n\nimport java.io.IOException;\nimport java.util.Comparator;\n\nimport org.apache.common"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/BooleanAbsoluteHomology.java",
    "chars": 1638,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/BooleanClassicalHomology.java",
    "chars": 5049,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\n\r\nimport "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/BooleanPersistenceAlgorithm.java",
    "chars": 4906,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\n\r\nimport "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/BooleanPersistentHomology.java",
    "chars": 10055,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\nimport ja"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/BooleanRelativeHomology.java",
    "chars": 1639,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/IntAbsoluteHomology.java",
    "chars": 1772,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/IntClassicalHomology.java",
    "chars": 5326,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/IntPersistenceAlgorithm.java",
    "chars": 5394,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/IntPersistentHomology.java",
    "chars": 10146,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\nimport ja"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/IntRelativeHomology.java",
    "chars": 1773,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/ObjectAbsoluteHomology.java",
    "chars": 1827,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/ObjectClassicalHomology.java",
    "chars": 5431,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\nimport ja"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/ObjectPersistenceAlgorithm.java",
    "chars": 5502,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\nimport ja"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/ObjectPersistentHomology.java",
    "chars": 10307,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\nimport ja"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/autogen/homology/ObjectRelativeHomology.java",
    "chars": 1828,
    "preview": "package edu.stanford.math.plex4.autogen.homology;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/bottleneck/BottleneckDistance.java",
    "chars": 4085,
    "preview": "package edu.stanford.math.plex4.bottleneck;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/bottleneck/FlowEdge.java",
    "chars": 1482,
    "preview": "package edu.stanford.math.plex4.bottleneck;\n\npublic class FlowEdge {\n\tprivate final int source;\n\tprivate final int dest;"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/bottleneck/FlowNetwork.java",
    "chars": 3319,
    "preview": "package edu.stanford.math.plex4.bottleneck;\n\nimport edu.stanford.math.primitivelib.autogen.pair.ObjectIntPair;\nimport gn"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/bottleneck/FordFulkerson.java",
    "chars": 3812,
    "preview": "package edu.stanford.math.plex4.bottleneck;\r\n\r\n/**\r\n * \r\n * The Ford-Fulkerson Algorithm\r\n * \r\n * \r\n * @author Tim Harri"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/bottleneck/FordFulkersonEdge.java",
    "chars": 1569,
    "preview": "package edu.stanford.math.plex4.bottleneck;\r\n\r\n/**\r\n * @author Tim Harrington\r\n * @date Mar 12, 2009\r\n *\r\n * This is fro"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/bottleneck/FordFulkersonNode.java",
    "chars": 1023,
    "preview": "package edu.stanford.math.plex4.bottleneck;\r\n\r\n/**\r\n * @author Tim Harrington\r\n * @date Mar 12, 2009\r\n *\r\n * This is fro"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/bottleneck/WeightedBipartiteGraph.java",
    "chars": 5116,
    "preview": "package edu.stanford.math.plex4.bottleneck;\n\nimport gnu.trove.THashSet;\n\nimport java.util.ArrayList;\nimport java.util.Co"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/examples/CellComplexOperations.java",
    "chars": 2238,
    "preview": "package edu.stanford.math.plex4.examples;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport edu.stanford.math."
  },
  {
    "path": "src/java/edu/stanford/math/plex4/examples/CellStreamExamples.java",
    "chars": 3810,
    "preview": "package edu.stanford.math.plex4.examples;\n\nimport edu.stanford.math.plex4.homology.chain_basis.Cell;\nimport edu.stanford"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/examples/DeSilvaMorozovJohanssonExample.java",
    "chars": 5924,
    "preview": "package edu.stanford.math.plex4.examples;\r\n\r\n\r\nimport edu.stanford.math.plex4.homology.barcodes.AnnotatedBarcodeCollecti"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/examples/PointCloudExamples.java",
    "chars": 9064,
    "preview": "package edu.stanford.math.plex4.examples;\r\n\r\nimport java.util.Arrays;\r\n\r\nimport edu.stanford.math.plex4.utility.RandomUt"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/examples/SimplexStreamExamples.java",
    "chars": 14058,
    "preview": "package edu.stanford.math.plex4.examples;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport edu.s"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/examples/SimplicialComplexOperations.java",
    "chars": 5418,
    "preview": "package edu.stanford.math.plex4.examples;\n\nimport edu.stanford.math.plex4.homology.chain_basis.Simplex;\nimport edu.stanf"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/generation/GeneratorDriver.java",
    "chars": 1788,
    "preview": "package edu.stanford.math.plex4.generation;\r\n\r\nimport java.util.List;\r\nimport java.util.Vector;\r\n\r\nimport edu.stanford.m"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/AbstractUndirectedGraph.java",
    "chars": 2081,
    "preview": "package edu.stanford.math.plex4.graph;\n\nimport java.io.Serializable;\nimport java.util.Iterator;\n\nimport edu.stanford.mat"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/AbstractWeightedUndirectedGraph.java",
    "chars": 809,
    "preview": "package edu.stanford.math.plex4.graph;\n\n/**\n * This interface defines functionality for a weighted graph.\n * The graph m"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/UndirectedListEdgeIterator.java",
    "chars": 1835,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.graph;\r\n\r\nimport java.util.Iterator;\r\n\r\nimport edu.stanford.math.primitiv"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/UndirectedListGraph.java",
    "chars": 5761,
    "preview": "/**\n * \n */\npackage edu.stanford.math.plex4.graph;\n\nimport edu.stanford.math.primitivelib.autogen.pair.IntIntPair;\nimpor"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/UndirectedWeightedListGraph.java",
    "chars": 5893,
    "preview": "/**\n * \n */\npackage edu.stanford.math.plex4.graph;\n\nimport edu.stanford.math.plex4.utility.ExceptionUtility;\nimport edu."
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/io/GraphDotWriter.java",
    "chars": 1041,
    "preview": "package edu.stanford.math.plex4.graph.io;\r\n\r\nimport java.io.BufferedWriter;\r\nimport java.io.FileWriter;\r\nimport java.io."
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/metric/GraphMetricFactory.java",
    "chars": 709,
    "preview": "package edu.stanford.math.plex4.graph.metric;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport e"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/metric/ShortestPathMetric.java",
    "chars": 1037,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.graph.metric;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedG"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/BAGraph.java",
    "chars": 4389,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport e"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/BinaryHierarchicalGraph.java",
    "chars": 6520,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport e"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/BinaryTree.java",
    "chars": 2266,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\n\r\n/**\r\n * Implements a binary tree of nodes labeled 1,2,...,n.\r\n * \r\n *"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/BinaryTreeGraph.java",
    "chars": 1813,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\n\r\n/**\r\n "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/CircleGraph.java",
    "chars": 3018,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport e"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/ClusteredERGraph.java",
    "chars": 5064,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.graph.random;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.Formatter;"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/ErdosRenyiGraph.java",
    "chars": 1514,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport java.text.DecimalFormat;\r\n\r\nimport edu.stanford.math.plex4.graph"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/ForestFireGraph.java",
    "chars": 3409,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport java.util.Random;\r\n\r\nimport cern.jet.random.AbstractDistribution"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/GraphInstanceGenerator.java",
    "chars": 1276,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport java.io.Serializable;\r\n\r\nimport edu.stanford.math.plex4.graph.Ab"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/HierarchicalERGraph.java",
    "chars": 3255,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.graph.random;\r\n\r\n/**\r\n * @author Tim Harrington\r\n * @date May 6, 2009\r\n *"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/KNearestNeighborsGraph.java",
    "chars": 841,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.primitivelib.autogen.array.Doub"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/ManifoldGraph.java",
    "chars": 3007,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport e"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/PrescribedDegrees.java",
    "chars": 6732,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport e"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/RandomGeometricGraph.java",
    "chars": 1993,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedG"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/SphereGraph.java",
    "chars": 773,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.plex4.examples.PointCloudExamples;\r\nimport edu"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/StochasticBlockmodel.java",
    "chars": 1735,
    "preview": "package edu.stanford.math.plex4.graph.random;\n\nimport java.text.DecimalFormat;\n\nimport edu.stanford.math.plex4.graph.Abs"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/random/TorusGraph.java",
    "chars": 1093,
    "preview": "package edu.stanford.math.plex4.graph.random;\r\n\r\nimport edu.stanford.math.primitivelib.autogen.array.DoubleArrayMath;\r\n\r"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/graph/utility/GraphUtility.java",
    "chars": 7694,
    "preview": "package edu.stanford.math.plex4.graph.utility;\r\n\r\nimport edu.stanford.math.plex4.graph.AbstractUndirectedGraph;\r\nimport "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/barcodes/AnnotatedBarcodeCollection.java",
    "chars": 8099,
    "preview": "package edu.stanford.math.plex4.homology.barcodes;\n\nimport java.util.HashMap;\nimport java.util.List;\nimport java.util.Ma"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/barcodes/BarcodeCollection.java",
    "chars": 2669,
    "preview": "package edu.stanford.math.plex4.homology.barcodes;\n\nimport java.util.List;\n\npublic class BarcodeCollection<T extends Com"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/barcodes/BarcodeUtility.java",
    "chars": 5936,
    "preview": "package edu.stanford.math.plex4.homology.barcodes;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport jav"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/barcodes/Interval.java",
    "chars": 11356,
    "preview": "package edu.stanford.math.plex4.homology.barcodes;\n\nimport java.io.Serializable;\n\n//import edu.stanford.math.primitiveli"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/barcodes/IntervalLengthComparator.java",
    "chars": 837,
    "preview": "package edu.stanford.math.plex4.homology.barcodes;\n\nimport java.util.Comparator;\n\npublic class IntervalLengthComparator "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/barcodes/PersistenceInvariantDescriptor.java",
    "chars": 10938,
    "preview": "package edu.stanford.math.plex4.homology.barcodes;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/chain_basis/Cell.java",
    "chars": 9634,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.homology.chain_basis;\r\n\r\nimport java.util.Arrays;\r\nimport java.util.Colle"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/chain_basis/CellComparator.java",
    "chars": 1477,
    "preview": "/**\r\n * \r\n */\r\npackage edu.stanford.math.plex4.homology.chain_basis;\r\n\r\nimport java.util.Comparator;\r\n\r\n/**\r\n * This cla"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/chain_basis/PrimitiveBasisElement.java",
    "chars": 2057,
    "preview": "package edu.stanford.math.plex4.homology.chain_basis;\n\n\n/**\n * This interface defines the functionality of a primitive b"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/chain_basis/Simplex.java",
    "chars": 3915,
    "preview": "package edu.stanford.math.plex4.homology.chain_basis;\r\n\r\nimport java.util.Arrays;\r\n\r\nimport edu.stanford.math.plex4.homo"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/chain_basis/SimplexComparator.java",
    "chars": 1590,
    "preview": "/**\n * \n */\npackage edu.stanford.math.plex4.homology.chain_basis;\n\nimport java.util.Comparator;\n\nimport edu.stanford.mat"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/chain_basis/SimplexPair.java",
    "chars": 2166,
    "preview": "package edu.stanford.math.plex4.homology.chain_basis;\r\n\r\nimport edu.stanford.math.primitivelib.autogen.pair.ObjectObject"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/chain_basis/SimplexPairComparator.java",
    "chars": 1164,
    "preview": "package edu.stanford.math.plex4.homology.chain_basis;\r\n\r\nimport java.util.Comparator;\r\n\r\npublic class SimplexPairCompara"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/filtration/ExternalConverter.java",
    "chars": 2201,
    "preview": "package edu.stanford.math.plex4.homology.filtration;\n\nimport java.util.Arrays;\n\n/**\n * <p>\n * This class implements a co"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/filtration/FiltrationConverter.java",
    "chars": 3049,
    "preview": "package edu.stanford.math.plex4.homology.filtration;\n\nimport edu.stanford.math.plex4.homology.barcodes.Interval;\nimport "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/filtration/FiltrationUtility.java",
    "chars": 1982,
    "preview": "package edu.stanford.math.plex4.homology.filtration;\n\nimport java.util.Iterator;\nimport java.util.List;\nimport java.util"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/filtration/IdentityConverter.java",
    "chars": 1152,
    "preview": "package edu.stanford.math.plex4.homology.filtration;\n\n\n\n/**\n * This class defines a filtration value conversion which si"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/filtration/IncreasingLinearConverter.java",
    "chars": 3589,
    "preview": "package edu.stanford.math.plex4.homology.filtration;\n\n\n\n/**\n * <p>This class implements a conversion between filtration "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/filtration/StaticConverter.java",
    "chars": 1538,
    "preview": "/**\n * \n */\npackage edu.stanford.math.plex4.homology.filtration;\n\n\n/**\n * This class implements the FiltrationConverter "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/interfaces/AbstractPersistenceAlgorithm.java",
    "chars": 1402,
    "preview": "package edu.stanford.math.plex4.homology.interfaces;\n\nimport edu.stanford.math.plex4.homology.barcodes.BarcodeCollection"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/interfaces/AbstractPersistenceBasisAlgorithm.java",
    "chars": 1911,
    "preview": "package edu.stanford.math.plex4.homology.interfaces;\n\nimport edu.stanford.math.plex4.homology.barcodes.AnnotatedBarcodeC"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/nonautogen/DisjointSetSystem.java",
    "chars": 1821,
    "preview": "package edu.stanford.math.plex4.homology.nonautogen;\n\n@Deprecated\npublic class DisjointSetSystem {\n\tint capacity = 16;\n\t"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/nonautogen/PersistentCohomologyPrototype.java",
    "chars": 10824,
    "preview": "package edu.stanford.math.plex4.homology.nonautogen;\n\nimport java.util.Comparator;\nimport java.util.HashMap;\nimport java"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/utility/HomologyUtility.java",
    "chars": 7648,
    "preview": "package edu.stanford.math.plex4.homology.utility;\r\n\r\nimport edu.stanford.math.plex4.homology.chain_basis.Simplex;\r\nimpor"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/AbstractHomologyTracker.java",
    "chars": 307,
    "preview": "package edu.stanford.math.plex4.homology.zigzag;\n\n\n\npublic interface AbstractHomologyTracker<K, I extends Comparable<I>,"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/AbstractPersistenceTracker.java",
    "chars": 360,
    "preview": "package edu.stanford.math.plex4.homology.zigzag;\n\nimport java.util.Map;\n\nimport edu.stanford.math.plex4.homology.barcode"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/BasisTrackingUtility.java",
    "chars": 13367,
    "preview": "package edu.stanford.math.plex4.homology.zigzag;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java."
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/HomologyBasisTracker.java",
    "chars": 19101,
    "preview": "package edu.stanford.math.plex4.homology.zigzag;\n\nimport java.util.Comparator;\nimport java.util.List;\nimport java.util.M"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/IntervalDescriptor.java",
    "chars": 1849,
    "preview": "/**\n * \n */\npackage edu.stanford.math.plex4.homology.zigzag;\n\n\npublic class IntervalDescriptor<T, G> {\n\tprotected final "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/IntervalTracker.java",
    "chars": 6723,
    "preview": "package edu.stanford.math.plex4.homology.zigzag;\n\nimport java.util.HashMap;\nimport java.util.Map;\n\nimport edu.stanford.m"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/SimpleHomologyBasisTracker.java",
    "chars": 9497,
    "preview": "package edu.stanford.math.plex4.homology.zigzag;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java."
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/ZigZagHomology.java",
    "chars": 3349,
    "preview": "package edu.stanford.math.plex4.homology.zigzag;\r\n\r\nimport java.util.Comparator;\r\n\r\nimport edu.stanford.math.plex4.homol"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/InducedHomologyMappingUtility.java",
    "chars": 13794,
    "preview": "package edu.stanford.math.plex4.homology.zigzag.bootstrap;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nim"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/SimplexStreamUtility.java",
    "chars": 1807,
    "preview": "package edu.stanford.math.plex4.homology.zigzag.bootstrap;\n\nimport edu.stanford.math.plex4.homology.chain_basis.Primitiv"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/VietorisRipsBootstrapper.java",
    "chars": 5597,
    "preview": "package edu.stanford.math.plex4.homology.zigzag.bootstrap;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport e"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/homology/zigzag/bootstrap/WitnessBootstrapper.java",
    "chars": 8076,
    "preview": "package edu.stanford.math.plex4.homology.zigzag.bootstrap;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport "
  },
  {
    "path": "src/java/edu/stanford/math/plex4/interop/Plex3PersistenceAlgorithm.java",
    "chars": 2264,
    "preview": "package edu.stanford.math.plex4.interop;\r\n\r\nimport edu.stanford.math.plex.Persistence;\r\nimport edu.stanford.math.plex.Pe"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/interop/Plex3Stream.java",
    "chars": 5265,
    "preview": "package edu.stanford.math.plex4.interop;\r\n\r\nimport java.util.Comparator;\r\nimport java.util.Iterator;\r\n\r\nimport edu.stanf"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/interop/Plex3ToPlex4BarcodeAdapter.java",
    "chars": 2094,
    "preview": "package edu.stanford.math.plex4.interop;\r\n\r\nimport edu.stanford.math.plex.PersistenceInterval;\r\nimport edu.stanford.math"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/interop/Plex3ToPlex4SimplexAdapter.java",
    "chars": 1664,
    "preview": "package edu.stanford.math.plex4.interop;\r\n\r\nimport edu.stanford.math.plex.Simplex;\r\nimport edu.stanford.math.plex4.homol"
  },
  {
    "path": "src/java/edu/stanford/math/plex4/io/BarcodeWriter.java",
    "chars": 1102,
    "preview": "package edu.stanford.math.plex4.io;\r\n\r\nimport java.awt.image.BufferedImage;\r\nimport java.io.IOException;\r\n\r\nimport edu.s"
  }
]

// ... and 391 more files (download for full content)