TDA4j
API
Generated with
TDA4j/org.appliedtopology.tda4j/org.appliedtopology.tda4j.algebra

org.appliedtopology.tda4j.algebra

package org.appliedtopology.tda4j.algebra

Members list

Type members

Experimental classlikes

trait Cell extends HasDimension

Attributes

Experimental
true
Supertypes
trait HasDimension
class Object
trait Matchable
class Any
Known subtypes
trait OrderedCell
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
trait Field

Attributes

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

Attributes

Companion
trait
Experimental
true
Supertypes
class Object
trait Matchable
class Any
Self type
Field.type
opaque class FiniteField(val p: Int)

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
trait HasDimension

Attributes

Experimental
true
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Cell
trait OrderedCell
trait OrderedBasis[CellT, CoefficientT]

The "leading term" (highest-priority cell and its coefficient, under CellT's own order) a formal sum needs to support pivot-based reduction. Currently has exactly one instance in this codebase, Chain's own chainIsOrderedBasis (Chain.scala) -- kept as a separate typeclass, in the same is-typeclass style as Cell/OrderedCell, rather than folded into Chain as ordinary methods, so leadingCell/leadingCoefficient read as a documented contract rather than incidental Chain API.

The "leading term" (highest-priority cell and its coefficient, under CellT's own order) a formal sum needs to support pivot-based reduction. Currently has exactly one instance in this codebase, Chain's own chainIsOrderedBasis (Chain.scala) -- kept as a separate typeclass, in the same is-typeclass style as Cell/OrderedCell, rather than folded into Chain as ordinary methods, so leadingCell/leadingCoefficient read as a documented contract rather than incidental Chain API.

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 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
case class SSetElement[G](word: List[Int], generator: G)

A simplex of a finitely-generated simplicial set, in Eilenberg–Zilber normal form: word is the strictly decreasing list of degeneracy indices [w1 > w2 > ... > wk] such that this element is s_w1 s_w2 ... s_wk (generator), read outermost-first (s_w1 is the last degeneracy applied). word = Nil means the element is generator, which must be non-degenerate. Dimension is generator's own dimension plus word.length.

A simplex of a finitely-generated simplicial set, in Eilenberg–Zilber normal form: word is the strictly decreasing list of degeneracy indices [w1 > w2 > ... > wk] such that this element is s_w1 s_w2 ... s_wk (generator), read outermost-first (s_w1 is the last degeneracy applied). word = Nil means the element is generator, which must be non-degenerate. Dimension is generator's own dimension plus word.length.

Decreasing, not increasing: s_i s_j = s_{j+1} s_i for i <= j takes a non-decreasing adjacent pair to a decreasing one, e.g. s_0 s_0 = s_1 s_0 -- so the (unique) normal form for "apply s_0 twice" is [1, 0], never [0, 1].

Attributes

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

Value members

Experimental methods

def faceOf[G](i: Int, word: List[Int], y: G, faces: G => IndexedSeq[SSetElement[G]]): SSetElement[G]

d_i on an arbitrary element s_w1 ... s_wk (y), given only the primitive face data on generators (faces(y)(i) = d_i(y), for y non-degenerate). Bottoms out on word = Nil; otherwise pushes d_i past the outermost degeneracy s_w1 via the simplicial identities:

d_i on an arbitrary element s_w1 ... s_wk (y), given only the primitive face data on generators (faces(y)(i) = d_i(y), for y non-degenerate). Bottoms out on word = Nil; otherwise pushes d_i past the outermost degeneracy s_w1 via the simplicial identities:

  • i < w1: d_i s_w1 = s_{w1-1} d_i (recurse on the same i, rewrap one dimension lower)
  • i in {w1, w1+1}: d_{w1} s_w1 = d_{w1+1} s_w1 = id (cancel: drop s_w1 entirely)
  • i > w1+1: d_i s_w1 = s_w1 d_{i-1} (recurse on i-1, rewrap at the same outer index)

faces(y) must return, for y of dimension n, exactly n+1 already-normalized elements of dimension n-1 (empty for n = 0) -- see FiniteSimplicialSet.validate() for a runtime check of this contract.

Attributes

Experimental
true
def insertOuter(m: Int, word: List[Int]): List[Int]

Composes a new outermost degeneracy s_m onto an already-normalized word, restoring the strictly-decreasing invariant via s_i s_j = s_{j+1} s_i (i <= j): if m already exceeds the current outermost index the word is untouched (already sorted); otherwise m must move past that index, incrementing it, and recurse.

Composes a new outermost degeneracy s_m onto an already-normalized word, restoring the strictly-decreasing invariant via s_i s_j = s_{j+1} s_i (i <= j): if m already exceeds the current outermost index the word is untouched (already sorted); otherwise m must move past that index, incrementing it, and recurse.

Attributes

Experimental
true

Givens

Experimental givens

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

Attributes

Experimental
true
Generated with