root
API
Generated with
root/org.appliedtopology.tda4j/org.appliedtopology.tda4j.cells/SimplexOps

SimplexOps

org.appliedtopology.tda4j.cells.SimplexOps
trait SimplexOps

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

A trait, mixed into object Simplex (Simplex.scala), rather than a top-level extension clause: Scala 3 does not allow same-named top-level extension methods for unrelated receiver types across different files in one package (confirmed empirically, not merely suspected -- see .claude/WORKLOG-cubical.md's "naming collision" section and .claude/WORKLOG-extension-companion-objects.md). Routing through the opaque type's own companion object instead scopes lookup by nominal receiver type, so a future opaque type's extensions can reuse a name like show/underlying without colliding with this one -- confirmed by a standalone scala-cli repro mirroring this exact shape (generic opaque type, non-generic companion, extension body split across two files) before this file was changed, not merely reasoned through.

Attributes

Experimental
true
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Simplex

Members list

Extensions

Extensions

extension [VertexT](spx: Simplex[VertexT])
def +(v: VertexT): Simplex[VertexT]
def ++(that: IterableOnce[VertexT]): Simplex[VertexT]
def -(v: VertexT): Simplex[VertexT]
def concat(that: IterableOnce[VertexT]): Simplex[VertexT]
def contains(elem: VertexT): Boolean
def count(p: VertexT => Boolean): Int
def dim: Int
def drop(n: Int): Simplex[VertexT]
def dropIndex(n: Int): Simplex[VertexT]
def dropRight(n: Int): Simplex[VertexT]
def dropWhile(p: VertexT => Boolean): Simplex[VertexT]
def excl(v: VertexT): Simplex[VertexT]
def exists(p: VertexT => Boolean): Boolean
def filter(pred: VertexT => Boolean): Simplex[VertexT]
def filterNot(pred: VertexT => Boolean): Simplex[VertexT]
def first: VertexT
def firstKey: VertexT
def firstOption: Option[VertexT]
def flatMap[B : Ordering](f: VertexT => IterableOnce[B]): Simplex[B]
def forall(p: VertexT => Boolean): Boolean
def foreach(f: VertexT => Unit): Unit
def head: VertexT
def headOption: Option[VertexT]
def incl(v: VertexT): Simplex[VertexT]
def isEmpty: Boolean
def iterator: Iterator[VertexT]
def last: VertexT
def lastKey: VertexT
def lastOption: Option[VertexT]
def map[B : Ordering](f: VertexT => B): Simplex[B]
def maxBefore(key: VertexT): Option[VertexT]
def maxBy[B : Ordering](f: VertexT => B): VertexT
def maxByOption[B : Ordering](f: VertexT => B): Option[VertexT]
def maxOption[B >: VertexT](using ordering: Ordering[B]): Option[B]
def minAfter(key: VertexT): Option[VertexT]
def minBy[B : Ordering](f: VertexT => B): VertexT
def minByOption[B : Ordering](f: VertexT => B): Option[VertexT]
def minOption[B >: VertexT](using ordering: Ordering[B]): Option[B]
def nonEmpty: Boolean
def show: String
def size: Int
def tail: Simplex[VertexT]
def tails: Iterator[Simplex[VertexT]]
def take(n: Int): Simplex[VertexT]
def takeRight(n: Int): Simplex[VertexT]
def toArray[B >: VertexT : ClassTag]: Array[B]
def toIndexedSeq: IndexedSeq[VertexT]
def toList: List[VertexT]
def toSeq: Seq[VertexT]
def toSet: Set[VertexT]
def toSortedSet: SortedSet[VertexT]
def union(that: Simplex[VertexT]): Simplex[VertexT]
def zip[B](that: IterableOnce[B]): Set[(VertexT, B)]
def zipAll[V >: VertexT, B](that: Iterable[B], thisElem: V, thatElem: B): Set[(V, B)]
def zipWithIndex: Set[(VertexT, Int)]
def |(that: Simplex[VertexT]): Simplex[VertexT]
Generated with