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

abstract class AlphaShapes 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
Known subtypes
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 SimplexStream[VertexT, FiltrationT]
class ExplicitStream[VertexT, FiltrationT]
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[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]
object Chain

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Chain.type
class Chain[CellT, CoefficientT]

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
trait Cocell extends HasDimension

Attributes

Experimental
true
Supertypes
trait HasDimension
class Object
trait Matchable
class Any
Known subtypes
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 CofacetIterator[VertexT](simplex: Simplex[VertexT], sparseMetricSpace: SparseMetricSpace[VertexT])(using evidence$1: Ordering[VertexT]) extends Iterator[VertexT]

******* Optimized Vietoris-Rips cofacet generation for fast coboundary computation *******

******* Optimized Vietoris-Rips cofacet generation for fast coboundary computation *******

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
trait Iterator[VertexT]
trait IterableOnceOps[VertexT, Iterator, Iterator[VertexT]]
trait IterableOnce[VertexT]
class Object
trait Matchable
class Any
Show all
case class DelaunaySimplex(simplex: Simplex[Int], circumsphere: Hypersphere)

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
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
Show all
class EnumeratingCofaceSimplexStream(val metricSpace: FiniteMetricSpace[Int], var keepCriterion: PartialFunction[Simplex[Int], Boolean] = ...) extends CofaceSimplexStream[Int, Double], DoubleFiltration[Simplex[Int]]

Attributes

Experimental
true
Supertypes
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
Known subtypes
final case class Epsilon(epsilon: Double)

Attributes

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

Attributes

Companion
class
Experimental
true
Supertypes
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
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 Pure
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]
object Field

Attributes

Companion
trait
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Field.type
trait Field

Attributes

Companion
object
Experimental
true
Supertypes
class Object
trait Matchable
class Any
trait Filterable[FiltrationT]

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Filtration[CellT, FiltrationT]
trait CellStream[CellT, FiltrationT]
trait SimplexStream[VertexT, FiltrationT]
class ExplicitStream[VertexT, FiltrationT]
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[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 SimplexStream[VertexT, FiltrationT]
class ExplicitStream[VertexT, FiltrationT]
class RipserStream
class SymmetricRipserStream[KeyT]
class RipserStreamOf[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
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
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
class IntMetricSpace[VertexT]
class SparseMetricSpace[VertexT]
Show all
object FractionalExpr

Attributes

Companion
trait
Experimental
true
Supertypes
trait Sum
trait Mirror
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
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
trait HasDimension

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Cell
trait OrderedCell
trait Cocell
class HelixDelaunay(pts: Array[Array[Double]])(using epsilon: Epsilon) extends AlphaShapes

Based on https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=10917453&tag=1

Based on https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=10917453&tag=1

Value parameters

pts
  • the input points to triangulate

Attributes

Experimental
true
Supertypes
class AlphaShapes
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 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
object Hyperplane

Attributes

Companion
class
Experimental
true
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Hyperplane.type
case class Hyperplane(normal: Point, offset: Double)

Attributes

Companion
object
Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class Hypersphere(center: Point, radius: Double)(using epsilon: Epsilon)

Attributes

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

Attributes

Companion
class
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
class InorderCofaceSimplexStream(metricSpace: FiniteMetricSpace[Int], keepCriterion: PartialFunction[Simplex[Int], Boolean] = ...) extends EnumeratingCofaceSimplexStream

Attributes

Experimental
true
Supertypes
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 IntMetricSpace[VertexT](val metricSpace: FiniteMetricSpace[VertexT]) extends FiniteMetricSpace[Int]

Wrapper class to make any metricspace into a metricspace defined on indices 0 through metricSpace.size. This way, code can assume that the index set is contiguous.

Wrapper class to make any metricspace into a metricspace defined on indices 0 through metricSpace.size. This way, code can assume that the index set is contiguous.

Type parameters

VertexT

Type of the vertex indices for the wrapped metric space

Value parameters

metricSpace

Wrapped metric space

Attributes

Experimental
true
Supertypes
trait FiniteMetricSpace[Int]
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
class LimitedCofaceSimplexStream(stream: CofaceSimplexStream[Int, Double], maxDim: Int) extends CofaceSimplexStream[Int, Double], DoubleFiltration[Simplex[Int]]

Attributes

Experimental
true
Supertypes
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 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])

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
class MiniballDelaunay(val points: Array[Array[Double]]) extends AlphaShapes

Attributes

Experimental
true
Supertypes
class AlphaShapes
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
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
trait OrderedCocell extends Cocell

Attributes

Experimental
true
Supertypes
trait Cocell
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
class PersistenceInChunksContext[VertexT, CoefficientT](maxDim: Int = ...)(using evidence$1: Ordering[VertexT], evidence$2: Field { type Self = CoefficientT; })

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
object Point

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Point.type
case class RecursiveStackSimplexEnumerator(metricSpace: FiniteMetricSpace[Int], targetDimension: Int = ...)(query: SpatialQuery[Int] = ...) extends Iterator[Simplex[Int]]

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
trait Iterator[Simplex[Int]]
trait IterableOnceOps[Simplex[Int], Iterator, Iterator[Simplex[Int]]]
trait IterableOnce[Simplex[Int]]
class Object
trait Matchable
class Any
Show all
class RecursiveStackVietorisRipsSimplexStream(val metricSpace: FiniteMetricSpace[Int]) 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
object Ridge

Attributes

Companion
class
Experimental
true
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Ridge.type
case class Ridge(normals: (Point, Point))

Attributes

Companion
object
Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
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

****** Maybe @deprecate or outright everything below here? ******

****** Maybe @deprecate or outright everything below here? ******

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
class RipserCofaceSimplexStream(metricSpace: FiniteMetricSpace[Int], keepCriterion: PartialFunction[Simplex[Int], Boolean] = ...) extends EnumeratingCofaceSimplexStream

Attributes

Experimental
true
Supertypes
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
object Simplex

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Simplex.type
object SimplexEdge

Attributes

Companion
class
Experimental
true
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
case class SimplexEdge(simplex: Simplex[Int], edge: Simplex[Int], diameter: Double)

Attributes

Companion
object
Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
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]
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: Field { type Self = 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 SparseMetricSpace[VertexT](metricSpace: FiniteMetricSpace[VertexT], diameter: Double)(using evidence$1: Ordering[VertexT]) extends FiniteMetricSpace[VertexT]

****** Sparse Metric Spaces and the Dory storage *******

****** Sparse Metric Spaces and the Dory storage *******

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
trait FiniteMetricSpace[VertexT]
class Object
trait Matchable
class Any
Show all
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]
Show all
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]
Show all
class SymmetricRipserCliqueFinder[KeyT](val symmetryGroup: SymmetryGroup[KeyT, Int])

Attributes

Experimental
true
Supertypes
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])

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 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
case class TopCofacetEnumerator(simplex: SimplexEdge, neighbors: SortedSet[Int])(using metricSpace: FiniteMetricSpace[Int])

Attributes

Experimental
true
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
class UnionFind[T](vertices: IterableOnce[T])

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
object doubleHandler extends FractionalHandler

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type

Types

type Point = RealVector
opaque type Simplex[VertexT]

Simplices really are just sets, outright. We provide an implementation of the [OrderedCell] typeclass for simplicial complex structures, to enable their use.

Simplices really are just sets, outright. We provide an implementation of the [OrderedCell] typeclass for simplicial complex structures, to enable their use.

Attributes

Value members

Experimental methods

def Alpha(pts: Seq[Array[Double]], dispatch: String = ...)(using epsilon: Epsilon): AlphaShapes

Attributes

Experimental
true
def Simplex_is_OrderedCell[VertexT](using vtxOrd: Ordering[VertexT])(setOrdering: Ordering[Simplex[VertexT]] = ...): is[Simplex[VertexT], OrderedCell]

Attributes

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

Attributes

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

Attributes

Experimental
true
def binomialBigint(n: Int, k: Int): BigInt

Attributes

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

Attributes

Experimental
true
def ∆[VertexT : Ordering](vertices: VertexT*): Simplex[VertexT]

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 default_Simplex_is_OrderedCell: [VertexT : Ordering] => is[Simplex[VertexT], OrderedCell]

Attributes

Experimental
true
given given_Epsilon: Epsilon

Attributes

Experimental
true
given given_Fractional_FractionalExpr: Fractional[FractionalExpr]

Attributes

Experimental
true
given given_Option_Filterable: [FiltrationT : Filterable] => Option[Filterable[FiltrationT]]

Attributes

Experimental
true
given given_Ordering_CellT: [CellT] => OrderedCell { type Self = CellT; } => Ordering[CellT]

Attributes

Experimental
true
given given_Ordering_CocellT: [CocellT] => OrderedCocell { type Self = CocellT; } => Ordering[CocellT]

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

Extensions

Experimental extensions

extension [VertexT](spx: Simplex[VertexT])
def +(v: VertexT): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def ++(that: IterableOnce[VertexT]): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def -(v: VertexT): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def concat(that: IterableOnce[VertexT]): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def contains(elem: VertexT): Boolean

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def count(p: VertexT => Boolean): Int

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def dim: Int

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def drop(n: Int): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def dropIndex(n: Int): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def dropRight(n: Int): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def dropWhile(p: VertexT => Boolean): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def excl(v: VertexT): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def exists(p: VertexT => Boolean): Boolean

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def filter(pred: VertexT => Boolean): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def filterNot(pred: VertexT => Boolean): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def first: VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def firstKey: VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def firstOption: Option[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def flatMap[B : Ordering](f: VertexT => IterableOnce[B]): Simplex[B]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def forall(p: VertexT => Boolean): Boolean

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def head: VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def headOption: Option[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def incl(v: VertexT): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def isEmpty: Boolean

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def last: VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def lastKey: VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def lastOption: Option[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def map[B : Ordering](f: VertexT => B): Simplex[B]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def max[B >: VertexT : Ordering]: VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def maxAfter(key: VertexT): Option[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def maxBy[B : Ordering](f: VertexT => B): VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def maxByOption[B : Ordering](f: VertexT => B): Option[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def maxOption[B >: VertexT](using ordering: Ordering[B]): Option[B]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def min[B >: VertexT : Ordering]: VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def minAfter(key: VertexT): Option[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def minBy[B : Ordering](f: VertexT => B): VertexT

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def minByOption[B : Ordering](f: VertexT => B): Option[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def minOption[B >: VertexT](using ordering: Ordering[B]): Option[B]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def nonEmpty: Boolean

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def show: String

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def size: Int

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def tail: Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def tails: Iterator[Simplex[VertexT]]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def take(n: Int): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def takeRight(n: Int): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def toArray[B >: VertexT : ClassTag]: Array[B]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def toIndexedSeq: IndexedSeq[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def toList: List[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def toSeq: Seq[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def toSet: Set[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def toSortedSet: SortedSet[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def union(that: Simplex[VertexT]): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def zip[B](that: IterableOnce[B]): Set[(VertexT, B)]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def zipAll[V >: VertexT, B](that: Iterable[B], thisElem: V, thatElem: B): Set[(V, B)]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def zipWithIndex: Set[(VertexT, Int)]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
def |(that: Simplex[VertexT]): Simplex[VertexT]

Inherit a selection of the SortedSet methods and add other utility methods

Inherit a selection of the SortedSet methods and add other utility methods

Attributes

Experimental
true
Generated with