root
API
Generated with
root/org.appliedtopology.tda4j

org.appliedtopology.tda4j

package org.appliedtopology.tda4j

Package for the Scala library TDA4j

Attributes

Members list

Packages

package org.appliedtopology.tda4j.barcode
package org.appliedtopology.tda4j.unicode

Type members

Experimental classlikes

class AlphaShapes(val points: Array[Array[Double]]) extends StratifiedSimplexStream[Int, Double], DoubleFiltration[Simplex[Int]]

Attributes

Experimental
true
Supertypes
trait StratifiedSimplexStream[Int, Double]
trait StratifiedCellStream[Simplex[Int], Double]
trait CellStream[Simplex[Int], Double]
trait IterableOnce[Simplex[Int]]
trait Filtration[Simplex[Int], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
class BronKerbosch[VertexT] extends CliqueFinder[VertexT]

BronKerbosch implements the creation of a Vietoris-Rips complex by running the Bron-Kerbosch clique finder algorithm and then sorting the resulting cliques before returning them in a Seq[FilteredAbstractSimplex[V,Double]].

BronKerbosch implements the creation of a Vietoris-Rips complex by running the Bron-Kerbosch clique finder algorithm and then sorting the resulting cliques before returning them in a Seq[FilteredAbstractSimplex[V,Double]].

Implements apply so that you call the object with an appropriate metric space and optional maximum filtration value and receive a sequence of simplices back.

Attributes

Experimental
true
Supertypes
class CliqueFinder[VertexT]
trait (FiniteMetricSpace[VertexT], Double, Int) => Seq[Simplex[VertexT]]
class Object
trait Matchable
class Any
case class BruteForce[VertexT](metricSpace: FiniteMetricSpace[VertexT]) extends SpatialQuery[VertexT]

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
trait SpatialQuery[VertexT]
class Object
trait Matchable
class Any
Show all
trait Cell extends HasDimension

Attributes

Experimental
true
Supertypes
trait HasDimension
class Object
trait Matchable
class Any
Known subtypes
trait OrderedCell
trait CellStream[CellT, FiltrationT] extends Filtration[CellT, FiltrationT], IterableOnce[CellT]

Attributes

Experimental
true
Supertypes
trait IterableOnce[CellT]
trait Filtration[CellT, FiltrationT]
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait CubeStream[FiltrationT]
trait SimplexStream[VertexT, FiltrationT]
class ExplicitStream[VertexT, FiltrationT]
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[VertexT]
class VietorisRips[VertexT]
trait StratifiedCellStream[CellT, FiltrationT]
trait StratifiedSimplexStream[VertexT, FiltrationT]
class AlphaShapes
trait CofaceSimplexStream[VertexT, FiltrationT]
Show all
class CellularHomologyContext[CellT, CoefficientT, FiltrationT]

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class SimplicialHomologyContext[VertexT, CoefficientT, FiltrationT]
class TDAContext[VertexT, CoefficientT, FiltrationT]
class Chain[CellT, CoefficientT]

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
object Chain

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Chain.type
abstract class CliqueFinder[VertexT] extends (FiniteMetricSpace[VertexT], Double, Int) => Seq[Simplex[VertexT]]

Attributes

Companion
object
Experimental
true
Supertypes
trait (FiniteMetricSpace[VertexT], Double, Int) => Seq[Simplex[VertexT]]
class Object
trait Matchable
class Any
Known subtypes
class BronKerbosch[VertexT]
class SymmetricZomorodianIncremental[VertexT, KeyT]
class ZomorodianIncremental[VertexT]
Show all
object CliqueFinder

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
trait CofaceSimplexStream[VertexT, FiltrationT] extends StratifiedSimplexStream[VertexT, FiltrationT]

Attributes

Experimental
true
Supertypes
trait StratifiedSimplexStream[VertexT, FiltrationT]
trait StratifiedCellStream[Simplex[VertexT], FiltrationT]
trait CellStream[Simplex[VertexT], FiltrationT]
trait IterableOnce[Simplex[VertexT]]
trait Filtration[Simplex[VertexT], FiltrationT]
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Show all
Known subtypes
case class Coproduct(left: SimplicialSet, right: SimplicialSet) extends SimplicialSet

The coproduct of two simplicial sets, defined as the simplicial set generated by the union of generators of the two lists.

The coproduct of two simplicial sets, defined as the simplicial set generated by the union of generators of the two lists.

If simplices happen to be in both the factors, this implementation currently makes no effort to distinguish them. Face maps will be tried from both factors, using the left-most that is actually defined on the given element. Both of these implementation choices may be unwise.

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
trait CubeStream[FiltrationT] extends CellStream[ElementaryCube, FiltrationT]

Attributes

Experimental
true
Supertypes
trait CellStream[ElementaryCube, FiltrationT]
trait IterableOnce[ElementaryCube]
trait Filtration[ElementaryCube, FiltrationT]
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Show all
object Cubical

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Cubical.type
case class DegenerateInterval(n: Int) extends ElementaryInterval

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class DegenerateSimplicialSetElement extends SimplicialSetElement

Primary class for representing a generic SimplicialSetElement. This case class carries references to its base element and a list of degeneracies. (both simplicialGenerator and SimplicialWrapper will specifically create elements without degeneracies and are meant to be used as base elements)

Primary class for representing a generic SimplicialSetElement. This case class carries references to its base element and a list of degeneracies. (both simplicialGenerator and SimplicialWrapper will specifically create elements without degeneracies and are meant to be used as base elements)

If you have no reason to build something else, your simplicial set elements should probably be instances of this case class.

Instantiation is through the companion object, where the public constructor does some normalization on the data the object carries.

Attributes

Companion
object
Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object DegenerateSimplicialSetElement

Attributes

Companion
class
Experimental
true
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
trait DoubleFiltration[CellT] extends Filtration[CellT, Double]

Attributes

Experimental
true
Supertypes
trait Filtration[CellT, Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Known subtypes
class AlphaShapes
case class ElementaryCube(intervals: List[ElementaryInterval])

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait ElementaryInterval

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class FullInterval
object ElementaryInterval

Attributes

Companion
trait
Experimental
true
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
class EuclideanMetricSpace(val pts: Array[Array[Double]]) extends FiniteMetricSpace[Int]

Takes in an point cloud and computes the Euclidean distance on demand.

Takes in an point cloud and computes the Euclidean distance on demand.

Value parameters

pts

Point cloud matrix represented as a Seq[Seq[Double]]. The class expects but does not enforce:

  • pts(x1).size == pts(x2).size for all x1,x2

Attributes

Companion
object
Experimental
true
Supertypes
trait FiniteMetricSpace[Int]
class Object
trait Matchable
class Any
object EuclideanMetricSpace

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
class ExpandList[VertexT, KeyT](val representatives: Seq[Simplex[VertexT]], val symmetry: SymmetryGroup[KeyT, VertexT])(using evidence$1: Ordering[VertexT]) extends IndexedSeq[Simplex[VertexT]]

A symmetry-aware compressed indexed sequence container that keeps track of representatives of each orbit, and generates the rest of the orbit as and when needed, including an iterator structure that also only generates the rest of the orbit when needed, and a method for checking whether a particular simplex is an orbit representatives in a way that does not hold on to orbit elements (thus allowing them to get instantly garbage collected).

A symmetry-aware compressed indexed sequence container that keeps track of representatives of each orbit, and generates the rest of the orbit as and when needed, including an iterator structure that also only generates the rest of the orbit when needed, and a method for checking whether a particular simplex is an orbit representatives in a way that does not hold on to orbit elements (thus allowing them to get instantly garbage collected).

Type parameters

KeyT

The type of the group element indices.

VertexT

The type of the vertices.

Value parameters

ordering$VertexT$0

We depend on a total order of simplices, which we generate from a total order of vertices. This carries that ordering.

representatives

A sequence of simplices, each representative for its own orbit

symmetry

A SymmetryGroup object carrying information about symmetries

Attributes

Experimental
true
Supertypes
trait IndexedSeq[Simplex[VertexT]]
trait IndexedSeqOps[Simplex[VertexT], IndexedSeq, IndexedSeq[Simplex[VertexT]]]
trait IndexedSeq[Simplex[VertexT]]
trait IndexedSeqOps[Simplex[VertexT], IndexedSeq, IndexedSeq[Simplex[VertexT]]]
trait Seq[Simplex[VertexT]]
trait SeqOps[Simplex[VertexT], IndexedSeq, IndexedSeq[Simplex[VertexT]]]
trait Seq[Simplex[VertexT]]
trait Equals
trait SeqOps[Simplex[VertexT], IndexedSeq, IndexedSeq[Simplex[VertexT]]]
trait PartialFunction[Int, Simplex[VertexT]]
trait Int => Simplex[VertexT]
trait Iterable[Simplex[VertexT]]
trait Iterable[Simplex[VertexT]]
trait IterableFactoryDefaults[Simplex[VertexT], IndexedSeq]
trait IterableOps[Simplex[VertexT], IndexedSeq, IndexedSeq[Simplex[VertexT]]]
trait IterableOnceOps[Simplex[VertexT], IndexedSeq, IndexedSeq[Simplex[VertexT]]]
trait IterableOnce[Simplex[VertexT]]
class Object
trait Matchable
class Any
Show all
Self type
ExpandList[VertexT, KeyT]
class ExplicitMetricSpace(val dist: Seq[Seq[Double]]) extends FiniteMetricSpace[Int]

Takes in an explicit distance matrix, and performs lookups in this distance matrix.

Takes in an explicit distance matrix, and performs lookups in this distance matrix.

Value parameters

dist

Distance matrix represented as a Seq[Seq[Double]]. The class expects but does not enforce:

  • dist(x1).size == dist(x2).size for all x1,x2
  • dist(x).size == dist.size for all x
  • dist(x)(x) == 0 for all x
  • The triangle inequality

Attributes

Experimental
true
Supertypes
trait FiniteMetricSpace[Int]
class Object
trait Matchable
class Any
class ExplicitStream[VertexT, FiltrationT](val filtrationValues: Map[Simplex[VertexT], FiltrationT], val simplices: Seq[Simplex[VertexT]])(using filterable: Filterable[FiltrationT])(using evidence$1: Ordering[VertexT], ordering: Ordering[FiltrationT]) extends SimplexStream[VertexT, FiltrationT]

Attributes

Experimental
true
Supertypes
trait SimplexStream[VertexT, FiltrationT]
trait CellStream[Simplex[VertexT], FiltrationT]
trait IterableOnce[Simplex[VertexT]]
trait Filtration[Simplex[VertexT], FiltrationT]
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Show all
Self type
ExplicitStream[VertexT, FiltrationT]
class ExplicitStreamBuilder[VertexT, FiltrationT](using ordering: Ordering[FiltrationT])(using evidence$1: Ordering[VertexT], filterableO: Option[Filterable[FiltrationT]]) extends ReusableBuilder[(FiltrationT, Simplex[VertexT]), ExplicitStream[VertexT, FiltrationT]]

Attributes

Experimental
true
Supertypes
trait ReusableBuilder[(FiltrationT, Simplex[VertexT]), ExplicitStream[VertexT, FiltrationT]]
trait Builder[(FiltrationT, Simplex[VertexT]), ExplicitStream[VertexT, FiltrationT]]
trait Growable[(FiltrationT, Simplex[VertexT])]
trait Clearable
class Object
trait Matchable
class Any
Show all
Self type
ExplicitStreamBuilder[VertexT, FiltrationT]
trait Filterable[FiltrationT]

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Filtration[CellT, FiltrationT]
trait CellStream[CellT, FiltrationT]
trait CubeStream[FiltrationT]
trait SimplexStream[VertexT, FiltrationT]
class ExplicitStream[VertexT, FiltrationT]
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[VertexT]
class VietorisRips[VertexT]
trait StratifiedCellStream[CellT, FiltrationT]
trait StratifiedSimplexStream[VertexT, FiltrationT]
class AlphaShapes
trait CofaceSimplexStream[VertexT, FiltrationT]
trait DoubleFiltration[CellT]
Show all
class FilteredSimplexOrdering[VertexT, FiltrationT](val filtration: Filtration[Simplex[VertexT], FiltrationT])(using vertexOrdering: Ordering[VertexT])(using filtrationOrdering: Ordering[FiltrationT]) extends Ordering[Simplex[VertexT]]

Attributes

Experimental
true
Supertypes
trait Ordering[Simplex[VertexT]]
trait PartialOrdering[Simplex[VertexT]]
trait Equiv[Simplex[VertexT]]
trait Serializable
trait Comparator[Simplex[VertexT]]
class Object
trait Matchable
class Any
Show all
trait Filtration[CellT, FiltrationT] extends Filterable[FiltrationT]

Attributes

Experimental
true
Supertypes
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Known subtypes
trait CellStream[CellT, FiltrationT]
trait CubeStream[FiltrationT]
trait SimplexStream[VertexT, FiltrationT]
class ExplicitStream[VertexT, FiltrationT]
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[VertexT]
class VietorisRips[VertexT]
trait StratifiedCellStream[CellT, FiltrationT]
trait StratifiedSimplexStream[VertexT, FiltrationT]
class AlphaShapes
trait CofaceSimplexStream[VertexT, FiltrationT]
trait DoubleFiltration[CellT]
Show all
opaque class FiniteField(val p: Int)

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
trait FiniteMetricSpace[VertexT]

Interface for being a finite metric space

Interface for being a finite metric space

Type parameters

VertexT

Type of the vertex indices for the metric space

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class HyperCube
object FiniteMetricSpace

Convenience functionality for metric spaces.

Convenience functionality for metric spaces.

Attributes

Companion
trait
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
sealed trait FractionalExpr

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Div
class Inv
class Minus
class Negate
object One
class Plus
class Prod
class Succ
class Sum
class Times
object Zero
Show all
object FractionalExpr

Attributes

Companion
trait
Experimental
true
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
trait FractionalHandler

This functionality is an experiment in using algebraic effect structures for flexible coefficient choices. The idea is that each actual computation that is needed is built up as an AST, and simplified; and a coefficient choice is an effect handler that evaluates the remainder in the field of coefficients to be used.

This functionality is an experiment in using algebraic effect structures for flexible coefficient choices. The idea is that each actual computation that is needed is built up as an AST, and simplified; and a coefficient choice is an effect handler that evaluates the remainder in the field of coefficients to be used.

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object doubleHandler
case class FullInterval(n: Int) extends ElementaryInterval

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
trait HasDimension

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Cell
trait OrderedCell
class HyperCube(bitlength: Int) extends FiniteMetricSpace[Int]

Attributes

Experimental
true
Supertypes
trait FiniteMetricSpace[Int]
class Object
trait Matchable
class Any
class HyperCubeBitSet(bitlength: Int) extends FiniteMetricSpace[BitSet]

The HyperCube example of a symmetric point set. Vertices are all binary strings of length bitlength. Distances on the hypercube are Hamming distances between binary strings, ie how many bits differ between the two strings.

The HyperCube example of a symmetric point set. Vertices are all binary strings of length bitlength. Distances on the hypercube are Hamming distances between binary strings, ie how many bits differ between the two strings.

Binary strings are throughout represented as immutable.BitSet.

Value parameters

bitlength

The dimension of the hypercube.

Attributes

Experimental
true
Supertypes
trait FiniteMetricSpace[BitSet]
class Object
trait Matchable
class Any
class HyperCubeSymmetry(bitlength: Int) extends SymmetryGroup[Int, Int]

Attributes

Experimental
true
Supertypes
trait SymmetryGroup[Int, Int]
class Object
trait Matchable
class Any
Known subtypes
class HyperCubeSymmetryBitSet(bitlength: Int) extends SymmetryGroup[Int, BitSet]

Symmetry group of the hypercube under permutations of bit positions. No rotations of the hypercube included here.

Symmetry group of the hypercube under permutations of bit positions. No rotations of the hypercube included here.

Value parameters

bitlength

Dimension of the hypercube.

Attributes

Experimental
true
Supertypes
trait SymmetryGroup[Int, BitSet]
class Object
trait Matchable
class Any
Known subtypes
class HyperCubeSymmetryGenerators(val bitlength: Int) extends HyperCubeSymmetry

Attributes

Experimental
true
Supertypes
trait SymmetryGroup[Int, Int]
class Object
trait Matchable
class Any
class HyperCubeSymmetryGeneratorsBitSet(val bitlength: Int) extends HyperCubeSymmetryBitSet

Attributes

Experimental
true
Supertypes
trait SymmetryGroup[Int, BitSet]
class Object
trait Matchable
class Any
case class JVPTree[VertexT](metricSpace: FiniteMetricSpace[VertexT]) extends SpatialQuery[VertexT]

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
trait SpatialQuery[VertexT]
class Object
trait Matchable
class Any
Show all
class Kruskal[T](elements: Seq[T], distance: (T, T) => Double, maxDistance: Double)(using orderingT: Ordering[T])

This implementation of Kruskal's algorithm will return two iterators of vertex pairs: the first iterator is a Minimal Spanning Tree in increasing weight order, while the second iterator gives all the non-included

This implementation of Kruskal's algorithm will return two iterators of vertex pairs: the first iterator is a Minimal Spanning Tree in increasing weight order, while the second iterator gives all the non-included

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
object Kruskal

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Kruskal.type
case class LazySimplicialSet(generators: LazyList[SimplicialSetElement], faceMapping: PartialFunction[SimplicialSetElement, List[SimplicialSetElement]]) extends SimplicialSet

This is an implementation of the SimplicialSet trait that allows for infinite generating sets. It also assembles face maps for you from just defining them on the generators and inferring their results on degeneracies.

This is an implementation of the SimplicialSet trait that allows for infinite generating sets. It also assembles face maps for you from just defining them on the generators and inferring their results on degeneracies.

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
class LazyStratifiedCliqueFinder[VertexT]()(using evidence$1: Ordering[VertexT]) extends CliqueFinder[VertexT]

Attributes

Experimental
true
Supertypes
class CliqueFinder[VertexT]
trait (FiniteMetricSpace[VertexT], Double, Int) => Seq[Simplex[VertexT]]
class Object
trait Matchable
class Any
object LazyStratifiedVietorisRips

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
object LazyVietorisRips

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
class MaskedSymmetricRipserStream[KeyT](val metricSpace: FiniteMetricSpace[Int], val maxFiltrationValue: Double, val maxDimension: Int, val symmetryGroup: SymmetryGroup[KeyT, Int]) extends SimplexStream[Int, Double]

Attributes

Experimental
true
Supertypes
trait SimplexStream[Int, Double]
trait CellStream[Simplex[Int], Double]
trait IterableOnce[Simplex[Int]]
trait Filtration[Simplex[Int], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
class MaskedSymmetricRipserVR[KeyT](val symmetryGroup: SymmetryGroup[KeyT, Int])(using evidence$1: Ordering[KeyT]) extends CliqueFinder[Int]

Attributes

Experimental
true
Supertypes
class CliqueFinder[Int]
trait (FiniteMetricSpace[Int], Double, Int) => Seq[Simplex[Int]]
class Object
trait Matchable
class Any
trait OrderedBasis[CellT, CoefficientT]

Trait that defines what it means to have an ordered basis

Trait that defines what it means to have an ordered basis

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
trait OrderedCell extends Cell

Attributes

Experimental
true
Supertypes
trait Cell
trait HasDimension
class Object
trait Matchable
class Any
class Permutations(elementCount: Int)

This class enumerates permutations in order to allow permutations of bit-positions to fill out the symmetry group of the hypercube.

This class enumerates permutations in order to allow permutations of bit-positions to fill out the symmetry group of the hypercube.

Value parameters

elementCount

How many objects are permuted?

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
case class Product(left: SimplicialSet, right: SimplicialSet) extends SimplicialSet

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class ProductElement(left: SimplicialSetElement, right: SimplicialSetElement) extends SimplicialSetElement

For now this is only written for finitely generated simplicial sets.

For now this is only written for finitely generated simplicial sets.

Anything with potentially infinite generator sets will need special handling.

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class Pushout(left: SimplicialSet, center: SimplicialSet, right: SimplicialSet, f: PartialFunction[SimplicialSetElement, SimplicialSetElement], g: PartialFunction[SimplicialSetElement, SimplicialSetElement]) extends SimplicialSet

The Pushout of a diagram

The Pushout of a diagram

$left \xrightarrow{f} center \xleftarrow{g} right$ is the subset of the product $left \times right$ of elements that hit the same value in $center$.

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class QuotientSimplicialSet(quotientSet: SimplicialSet, superSet: SimplicialSet, projection: PartialFunction[SimplicialSetElement, SimplicialSetElement]) extends SimplicialSet

Attributes

Companion
object
Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object QuotientSimplicialSet

Attributes

Companion
class
Experimental
true
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
trait RingModule

Specifies what it means for the type Self to be a module (or vector space) over the [Numeric] (ie ring-like) type R.

Specifies what it means for the type Self to be a module (or vector space) over the [Numeric] (ie ring-like) type R.

A minimal implementation of this trait will define zero, plus, scale, and at least one of minus and negate

Type parameters

R

Type of the ring coefficients

Self

Type of the module elements.

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
class RipserCliqueFinder extends CliqueFinder[Int]

Attributes

Experimental
true
Supertypes
class CliqueFinder[Int]
trait (FiniteMetricSpace[Int], Double, Int) => Seq[Simplex[Int]]
class Object
trait Matchable
class Any
case class RipserCofaceSimplexStream(metricSpace: FiniteMetricSpace[Int], keepCriterion: PartialFunction[Simplex[Int], Boolean]) extends CofaceSimplexStream[Int, Double], DoubleFiltration[Simplex[Int]]

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
trait CofaceSimplexStream[Int, Double]
trait StratifiedSimplexStream[Int, Double]
trait StratifiedCellStream[Simplex[Int], Double]
trait CellStream[Simplex[Int], Double]
trait IterableOnce[Simplex[Int]]
trait Filtration[Simplex[Int], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
class RipserStream(metricSpace: FiniteMetricSpace[Int], maxFiltrationValue: Double, maxDimension: Int) extends RipserStreamBase

Attributes

Companion
object
Experimental
true
Supertypes
trait SimplexStream[Int, Double]
trait CellStream[Simplex[Int], Double]
trait IterableOnce[Simplex[Int]]
trait Filtration[Simplex[Int], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
Known subtypes
class SymmetricRipserStream[KeyT]
object RipserStream

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
abstract class RipserStreamBase(val metricSpace: FiniteMetricSpace[Int], val maxFiltrationValue: Double, val maxDimension: Int) extends SimplexStream[Int, Double]

Attributes

Experimental
true
Supertypes
trait SimplexStream[Int, Double]
trait CellStream[Simplex[Int], Double]
trait IterableOnce[Simplex[Int]]
trait Filtration[Simplex[Int], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
Known subtypes
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[VertexT](val metricSpace: FiniteMetricSpace[VertexT], val maxFiltrationValue: Double, val maxDimension: Int)(using evidence$1: Ordering[VertexT]) extends SimplexStream[VertexT, Double]

Attributes

Experimental
true
Supertypes
trait SimplexStream[VertexT, Double]
trait CellStream[Simplex[VertexT], Double]
trait IterableOnce[Simplex[VertexT]]
trait Filtration[Simplex[VertexT], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
class RipserStreamSparse(val metricSpace: FiniteMetricSpace[Int], val maxFiltrationValue: Double, val maxDimension: Int) extends SimplexStream[Int, Double]

Attributes

Experimental
true
Supertypes
trait SimplexStream[Int, Double]
trait CellStream[Simplex[Int], Double]
trait IterableOnce[Simplex[Int]]
trait Filtration[Simplex[Int], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
class ScalaPointSet(points: Array[Array[Double]]) extends PointSet

Attributes

Experimental
true
Supertypes
trait PointSet
class Object
trait Matchable
class Any
case class Simplex[VertexT]

Class representing an abstract simplex. Abstract simplices are given by sets (of totally ordered vertices) and inherit from Cell so that the class has a boundary and a dim method.

Class representing an abstract simplex. Abstract simplices are given by sets (of totally ordered vertices) and inherit from Cell so that the class has a boundary and a dim method.

You should never have reason to use the constructor directly (...and if you do, you should make sure to give the internal SortedSet yourself) - instead use the factory method in the companion object. In code this means that instead of new Simplex[Self](a,b,c) you would write Simplex[Self](a,b,c).

Type parameters

VertexT

Vertex type

Value parameters

ordering

Ordering of the vertex type

vertices

Vertices of the simplex

Attributes

Companion
object
Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Simplex

Simplex companion object with factory methods

Simplex companion object with factory methods

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Simplex.type
class SimplexIndexing(val vertexCount: Int)

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
trait SimplexStream[VertexT, FiltrationT] extends CellStream[Simplex[VertexT], FiltrationT]

Abstract trait for representing a sequence of simplices.

Abstract trait for representing a sequence of simplices.

Type parameters

FiltrationT

Type of the filtration values.

VertexT

Type of vertices of the contained simplices.

Attributes

Todo

We may want to change this to inherit instead from IterableOnce[Simplex[VertexT]], so that a lazy computed simplex stream can be created and fit in the type hierarchy.

Companion
object
Experimental
true
Supertypes
trait CellStream[Simplex[VertexT], FiltrationT]
trait IterableOnce[Simplex[VertexT]]
trait Filtration[Simplex[VertexT], FiltrationT]
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ExplicitStream[VertexT, FiltrationT]
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[VertexT]
class VietorisRips[VertexT]
Show all
object SimplexStream

Attributes

Companion
trait
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
class SimplicialHomologyByDimensionContext[VertexT, CoefficientT]

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
class SimplicialHomologyContext[VertexT, CoefficientT, FiltrationT]()(using evidence$1: Ordering[VertexT], evidence$2: Fractional[CoefficientT], evidence$3: Ordering[FiltrationT]) extends CellularHomologyContext[Simplex[VertexT], CoefficientT, FiltrationT]

Attributes

Experimental
true
Supertypes
class CellularHomologyContext[Simplex[VertexT], CoefficientT, FiltrationT]
class Object
trait Matchable
class Any
Known subtypes
class TDAContext[VertexT, CoefficientT, FiltrationT]
case class SimplicialMap(mapping: PartialFunction[SimplicialSetElement, SimplicialSetElement], source: SimplicialSet, target: SimplicialSet)

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
trait SimplicialSet

The interface for defining a simplicial set.

The interface for defining a simplicial set.

A simplicial set must have:

  1. A sequence of generating elements. These are considered non-degenerate in the context of this simplicial set. This sequence will be assumed to be in increasing order of dimension (so that things like nSkeleton can stop searching when it hits large enough dimensions), but this is not structurally enforced by the trait itself.
  2. For each index $i$, a partial function from SimplicialSetElement to SimplicialSetElement encoding the $i$th face map. These partial functions must be defined on all the generators.

With these building blocks, a simplicial set also has:

  1. A contains function with an ∋ alias.
  2. A method for listing all n-dimensional cells (degenerate as well as non-degenerate).
  3. A total order of SimplicialSetElements, as a given declaration.
  4. An instance of the Cell typeclass for SimplicialSetElements, as a given declaration. This instance works on the assumption that you will want to work in the normalized Moore complex, and will treat the generators as your cells.
  5. Functions to compute an f_vector (of non-degenerate elements), a full f-vector (of all elements), and the Euler characteristic.

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Coproduct
class Product
class Pushout
class Singular[VertexT]
Show all
object SimplicialSet

Attributes

Companion
trait
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
trait SimplicialSetElement

Defining trait for being an element of some simplicial set. Elements keep track of their own dimension, what degeneracies (if any) have been applied, and what the base non-degenerate element is.

Defining trait for being an element of some simplicial set. Elements keep track of their own dimension, what degeneracies (if any) have been applied, and what the base non-degenerate element is.

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object empty
object SimplicialSetElement

Attributes

Companion
trait
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
object SimplicialSetExamples

************** Examples

************** Examples

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
case class SimplicialWrapper[T](wrapped: T)(using evidence$1: HasDimension { type Self = T; }) extends SimplicialSetElement

Wrapper class to allow any data type with a defined dimension function (as witnessed by the typeclass HasDimension to be a base element for a SimplicialSetElement.

Wrapper class to allow any data type with a defined dimension function (as witnessed by the typeclass HasDimension to be a base element for a SimplicialSetElement.

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
class Singular[VertexT] extends SimplicialSet

The Singular Simplicial Set of a simplicial complex (seen as a sequence of simplices).

The Singular Simplicial Set of a simplicial complex (seen as a sequence of simplices).

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
object Singular

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Singular.type
trait SpatialQuery[VertexT]

******* Efficient Spatial Queries *******

******* Efficient Spatial Queries *******

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class BruteForce[VertexT]
class JVPTree[VertexT]
trait StratifiedCellStream[CellT, FiltrationT] extends CellStream[CellT, FiltrationT]

Attributes

Experimental
true
Supertypes
trait CellStream[CellT, FiltrationT]
trait IterableOnce[CellT]
trait Filtration[CellT, FiltrationT]
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait StratifiedSimplexStream[VertexT, FiltrationT]
class AlphaShapes
trait CofaceSimplexStream[VertexT, FiltrationT]
trait StratifiedSimplexStream[VertexT, FiltrationT] extends StratifiedCellStream[Simplex[VertexT], FiltrationT]

Attributes

Experimental
true
Supertypes
trait StratifiedCellStream[Simplex[VertexT], FiltrationT]
trait CellStream[Simplex[VertexT], FiltrationT]
trait IterableOnce[Simplex[VertexT]]
trait Filtration[Simplex[VertexT], FiltrationT]
trait Filterable[FiltrationT]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AlphaShapes
trait CofaceSimplexStream[VertexT, FiltrationT]
case class SubSimplicialSet(subSet: SimplicialSet, ambient: SimplicialSet, inclusion: PartialFunction[SimplicialSetElement, SimplicialSetElement]) extends SimplicialSet

Attributes

Companion
object
Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object SubSimplicialSet

Attributes

Companion
class
Experimental
true
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
case class SubSimplicialSetElement(base: SimplicialSetElement) extends SimplicialSetElement

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
class SymmetricRipserCliqueFinder[KeyT](val symmetryGroup: SymmetryGroup[KeyT, Int]) extends CliqueFinder[Int]

Attributes

Experimental
true
Supertypes
class CliqueFinder[Int]
trait (FiniteMetricSpace[Int], Double, Int) => Seq[Simplex[Int]]
class Object
trait Matchable
class Any
class SymmetricRipserStream[KeyT](metricSpace: FiniteMetricSpace[Int], maxFiltrationValue: Double, maxDimension: Int, val symmetryGroup: SymmetryGroup[KeyT, Int]) extends RipserStream

Attributes

Experimental
true
Supertypes
class RipserStream
trait SimplexStream[Int, Double]
trait CellStream[Simplex[Int], Double]
trait IterableOnce[Simplex[Int]]
trait Filtration[Simplex[Int], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
class SymmetricZomorodianIncremental[VertexT, KeyT](val symmetry: SymmetryGroup[KeyT, VertexT])(using evidence$1: Ordering[VertexT]) extends CliqueFinder[VertexT]

Symmetry-aware version of Zomorodian's incremental algorithm for generating Vietoris-Rips complexes. The algorithm object needs access to a SymmetryGroup instance that encodes all we know about the symmetries.

Symmetry-aware version of Zomorodian's incremental algorithm for generating Vietoris-Rips complexes. The algorithm object needs access to a SymmetryGroup instance that encodes all we know about the symmetries.

Type parameters

KeyT

Type of the indices for the group elements in symmetry.

VertexT

Type of the vertices of the complex.

Value parameters

ordering$VertexT$0

We need to sort simplices, so we need to sort vertices.

symmetry

Symmetry group details.

Attributes

Experimental
true
Supertypes
class CliqueFinder[VertexT]
trait (FiniteMetricSpace[VertexT], Double, Int) => Seq[Simplex[VertexT]]
class Object
trait Matchable
class Any
Self type
trait SymmetryGroup[KeyT, VertexT]()(using evidence$1: Ordering[VertexT])

A trait encoding the interface for a group of symmetries acting on the vertex set of a simplicial complex. The group and its action needs to be fully known and implemented.

A trait encoding the interface for a group of symmetries acting on the vertex set of a simplicial complex. The group and its action needs to be fully known and implemented.

This structure assumes that you can provide a group action on vertices, and will from that deduce a group action on simplices by acting pointwise: g.[a,b,c] = [ga,gb,gc], collapsing any degeneracies.

A fundamentally important part of the symmetry group action for our applications is to be able to pick out canonical representatives for each orbit, and to recognize when a simplex is such a canonical representative.

Type parameters

KeyT

The type used to enumerate the group elements.

VertexT

The type of the vertices.

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
Self type
SymmetryGroup[KeyT, VertexT]
class TDAContext[VertexT, CoefficientT, FiltrationT] extends SimplicialHomologyContext[VertexT, CoefficientT, FiltrationT]

Attributes

Experimental
true
Supertypes
class SimplicialHomologyContext[VertexT, CoefficientT, FiltrationT]
class CellularHomologyContext[Simplex[VertexT], CoefficientT, FiltrationT]
class Object
trait Matchable
class Any
class UnionFind[T](vertices: IterableOnce[T])

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
class VietorisRips[VertexT](using ordering: Ordering[VertexT])(val metricSpace: FiniteMetricSpace[VertexT], val maxFiltrationValue: Double, val maxDimension: Int, val cliqueFinder: CliqueFinder[VertexT]) extends SimplexStream[VertexT, Double]

Convenience definition to allow us to choose a specific implementation.

Convenience definition to allow us to choose a specific implementation.

Attributes

Returns

A function-like object with the signature

   VietorisRips : (MetricSpace[VertexT], Double) =>
 Seq[FilteredAbstractSimplex[VertexT,Double]]
Experimental
true
Supertypes
trait SimplexStream[VertexT, Double]
trait CellStream[Simplex[VertexT], Double]
trait IterableOnce[Simplex[VertexT]]
trait Filtration[Simplex[VertexT], Double]
trait Filterable[Double]
class Object
trait Matchable
class Any
Show all
Self type
VietorisRips[VertexT]
class ZomorodianIncremental[VertexT] extends CliqueFinder[VertexT]

Attributes

Experimental
true
Supertypes
class CliqueFinder[VertexT]
trait (FiniteMetricSpace[VertexT], Double, Int) => Seq[Simplex[VertexT]]
class Object
trait Matchable
class Any
object doubleHandler extends FractionalHandler

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
object given_is_ElementaryCube_OrderedCell extends is[ElementaryCube, OrderedCell]

Attributes

Experimental
true
Supertypes
trait OrderedCell
trait Cell
trait HasDimension
class Object
trait Matchable
class Any
Show all
Self type
object given_is_SimplicialSetElement_HasDimension extends is[SimplicialSetElement, HasDimension]

Attributes

Experimental
true
Supertypes
trait HasDimension
class Object
trait Matchable
class Any
Self type

Value members

Experimental methods

def alternateLazyLists[A](left: Seq[A], right: Seq[A]): LazyList[A]

Helper function to interleave two lazy lists -- so that we can take their union without having to run through one of them completely before going to the other one.

Helper function to interleave two lazy lists -- so that we can take their union without having to run through one of them completely before going to the other one.

Attributes

Experimental
true
def binomial(n: Int, k: Int): Int

Attributes

Experimental
true
def normalizedCellStream[FiltrationT](ss: SimplicialSet, filtrationValueO: Option[PartialFunction[SimplicialSetElement, FiltrationT]])(using evidence$1: Ordering[FiltrationT], evidence$2: Filterable[FiltrationT]): CellStream[SimplicialSetElement, FiltrationT]

Helper function to create a CellStream instance from any simplicial set. If no filtration value function is provided, it will use the constant function with the smallest value in the Filterable typeclass implementation for FiltrationT.

Helper function to create a CellStream instance from any simplicial set. If no filtration value function is provided, it will use the constant function with the smallest value in the Filterable typeclass implementation for FiltrationT.

Attributes

Experimental
true
def simplexOrdering[VertexT](using vtxOrdering: Ordering[VertexT]): Ordering[Simplex[VertexT]]

Attributes

Experimental
true
def simplicialGenerator(generatorDim: Int): SimplicialSetElement

Convenience function for comfortably generating one-shot implementations of SimplicialSetElement.

Convenience function for comfortably generating one-shot implementations of SimplicialSetElement.

Two SimplicialSetElements generated by this are unequal unless they are the exact same object instance.

Attributes

Experimental
true
def ∆[T](ts: T*)(using evidence$1: Ordering[T]): Simplex[T]

Convenience method for defining simplices

Convenience method for defining simplices

The character ∆ is typed as Alt+J on Mac GB layout, and has unicode code 0x0394.

Attributes

Experimental
true

Givens

Experimental givens

given DoubleIsFilterable: Filterable[Double]

Attributes

Experimental
true
given FloatIsFilterable: Filterable[Float]

Attributes

Experimental
true
given IntIsFilterable: Filterable[Int]

Attributes

Experimental
true
given LongIsFilterable: Filterable[Long]

Attributes

Experimental
true
given ShortIsFilterable: Filterable[Short]

Attributes

Experimental
true
given elementaryCubeOrdering: Ordering[ElementaryCube]

Attributes

Experimental
true
given elementaryIntervalOrdering: Ordering[ElementaryInterval]

Attributes

Experimental
true
given given_Fractional_FractionalExpr: Fractional[FractionalExpr]

Attributes

Experimental
true
given given_Option_Filterable[FiltrationT](using evidence$1: Filterable[FiltrationT]): Option[Filterable[FiltrationT]]

Attributes

Experimental
true
given given_Ordering_CellT[CellT](using oCell: OrderedCell { type Self = CellT; }): Ordering[CellT]

Attributes

Experimental
true
given given_Ordering_Simplex[VertexT](using evidence$1: Ordering[VertexT]): Ordering[Simplex[VertexT]]

Attributes

Experimental
true
given orderingBitSet: Ordering[BitSet]

A given instance that allows us to automatically sort bitsets lexicographically.

A given instance that allows us to automatically sort bitsets lexicographically.

Attributes

Experimental
true
Generated with