Seqs

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def binIntersect[A, B](aEls: Iterator[A], bEls: IndexedSeq[B], compare: (A, B) ⇒ Int): Iterator[(A, B)]

Compute the intersection of two sequences in (strictly) ascending order.

def binSearch[T](seq: IndexedSeq[T], begin: Int, end: Int, wanted: T)(implicit ord: Ordering[T]): BS_Result

Binary search for an element in a sorted random-access sequent.

def diff[A](newSeq: IndexedSeq[A], oldSeq: IndexedSeq[A])(implicit ord: Ordering[A]): (IndexedSeq[A], IndexedSeq[A])

Given to sequences that are totally sorted in the same descending order, determine those elements in newSeq that also occur in oldSeq, and those elements in newSeq that do not occur in oldSeq.

def diff3[A](seq0: IndexedSeq[A], seq1: IndexedSeq[A])(implicit ord: Ordering[A]): (IndexedSeq[A], IndexedSeq[A], IndexedSeq[A])

Given to sequences that are totally sorted in the same descending order, determine those elements that only occur in seq0, those that occur in both sequences, and those that only occur in seq1.

def disjoint[A](a: Set[A], b: Set[A], c: Set[A]): Boolean

Determine whether 3 given sets have any elements in common

def disjoint[A](a: Set[A], b: Set[A]): Boolean

def disjointSeq[A](a1: Set[A], a2: Set[A], b: Iterator[A]): Boolean

def disjointSeq[A](a1: Set[A], a2: Set[A], b: Iterable[A]): Boolean

def disjointSeq[A](a: Set[A], b: Iterable[A]): Boolean

def disjointSeq[A](a: Set[A], b: Iterator[A]): Boolean

def doubleIterator[A](a: A, b: A): Iterator[A]

Iterator over exactly two elements

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterAndSort[A](it: Iterator[A], skipEl: (A) ⇒ Boolean, badEl: (A) ⇒ Boolean, trafo: (A) ⇒ A, comesBefore: (A, A) ⇒ Boolean)(implicit arg0: ClassTag[A]): FAS_RESULT[A]

Filter a sequence of objects in order to detect the existence of certain bad objects (badEl) and to remove certain unnecessary objects (skipEl).

def findDuplicates[A](els: Iterator[A]): Set[A]

Determine all elements that occur in more than one of the given collections

final def getClass(): Class[_]

def hashCode(): Int

def identicalSeqs[A <: AnyRef](a: Iterable[A], b: Iterable[A]): Boolean

Determine whether the two given sequences/iterables contain reference-identical objects.

final def isInstanceOf[T0]: Boolean

def lexCombineInts(int1: Int, _int2: ⇒ Int, _int3: ⇒ Int, _int4: ⇒ Int): Int

def lexCombineInts(int1: Int, _int2: ⇒ Int, _int3: ⇒ Int): Int

def lexCombineInts(int1: Int, int2: ⇒ Int): Int

Interpret the given integers as results of a compare function (negative, zero, positive for less, equal, greater) and combine them lexicographically

def lexCompare[T](it1: Iterator[T], it2: Iterator[T])(implicit ord: Ordering[T]): Int

Lexicographic comparison of two lists of things

def lexCompareOrdering[T](it1: Iterator[T], it2: Iterator[T])(implicit ord: Ordering[T]): Int

def max[A, B](it: Iterator[A], measure: (A) ⇒ B)(implicit arg0: (B) ⇒ Ordered[B]): A

Determine a maximum element of a sequence of things under a given measure

def max(els: Iterable[Int]): Int

Compute the maximum of a sequence of ints.

def max(it: Iterator[Int]): Int

Compute the maximum of a sequence of ints.

def mergeSortedSeqs[A](aIt: Iterator[A], bIt: Iterator[A])(implicit ord: Ordering[A]): IndexedSeq[A]

Merge two sequences that are sorted in strictly descending order and produce a descending sequence with all elements occurring in at least one of the sequences

def mergeSortedSeqs[A](a: IndexedSeq[A], b: IndexedSeq[A])(implicit ord: Ordering[A]): IndexedSeq[A]

Merge two sequences that are sorted in strictly descending order and produce a descending sequence with all elements occurring in at least one of the sequences

def min[A, B](it: Iterator[A], measure: (A) ⇒ B)(implicit arg0: (B) ⇒ Ordered[B]): A

Determine a minimum element of a sequence of things under a given measure

def min[A, B](it: Iterable[A], measure: (A) ⇒ B)(implicit arg0: (B) ⇒ Ordered[B]): A

Determine a minimum element of a sequence of things under a given measure

def min(it: Iterator[Int]): Int

Compute the minimum of a sequence of ints.

def minOption[A, B](it: Iterator[A], measure: (A) ⇒ Option[B])(implicit arg0: (B) ⇒ Ordered[B]): Option[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optionMax(a: Option[IdealInt], b: Option[IdealInt]): Option[IdealInt]

Max on optional integers

def optionMin(a: Option[IdealInt], b: Option[IdealInt]): Option[IdealInt]

Min on optional integers

def optionSum(vals: Iterator[Option[Int]]): Option[Int]

Return the sum of the given numbers if all numbers are defined, None otherwise.

def partialMinBy[A, B](it: Iterator[A], f: (A) ⇒ B)(implicit cmp: PartialOrdering[B]): A

Determine a minimum element of a sequence of things under a given measure

def prepend[A](els: Iterable[A], l: List[A]): List[A]

Prepend some elements in front of a list

def reduceLeft[A](els: Iterable[A], f: (A, A) ⇒ A): Option[A]

reduceLeft that also works for empty sequences

def reduceLeft[A](els: Iterator[A], f: (A, A) ⇒ A): Option[A]

reduceLeft that also works for empty sequences

def removeDuplicates[A](s: IndexedSeq[A]): IndexedSeq[A]

Remove all duplicates from a sorted sequence.

def risingEdge[A](ar: IndexedSeq[A], p: (A) ⇒ Boolean): Int

Find the first index ind with p(ar(ind)); return 0 if p is true on the whole sequence, and end if p is false on the whole sequence.

def risingEdgeBwd[A](ar: IndexedSeq[A], p: (A) ⇒ Boolean, start: Int): Int

Going backward, find the first index ind in the range [0, start) with p(ar(ind)); return 0 if p is true on [0, start), and start if p is false on [0, start).

def risingEdgeBwdFull[A](ar: IndexedSeq[A], p: (A) ⇒ Boolean, start: Int, begin: Int): Int

Going backward, find the first index ind in the range [begin, start) with p(ar(ind)); return begin if p is true on [begin, start), and start if p is false on [begin, start).

def risingEdgeFull[A](ar: IndexedSeq[A], p: (A) ⇒ Boolean, begin: Int, end: Int): Int

Find the first index ind in the range [begin, end) with p(ar(ind)); return begin if p is true on [begin, end), and end if p is false on [begin, end).

def risingEdgeFwd[A](ar: IndexedSeq[A], p: (A) ⇒ Boolean, start: Int): Int

Going forward, find the first index ind in the range [start, ar.size) with p(ar(ind)); return start if p is true on [start, ar.size), and ar.size if p is false on [start, ar.size).

def risingEdgeFwdFull[A](ar: IndexedSeq[A], p: (A) ⇒ Boolean, start: Int, end: Int): Int

Going forward, find the first index ind in the range [start, end) with p(ar(ind)); return start if p is true on [start, end), and end if p is false on [start, end).

def so2os[T](l: Seq[Option[T]]): Option[Seq[T]]

Convert a sequence of options to an optional sequence.

def some[A](vals: Iterable[Option[A]]): Option[A]

def some[A](vals: Iterator[Option[A]]): Option[A]

Return the first Some(x) of the given sequence, or None if none exists

def split[A](els: Iterator[A], firstKind: (A) ⇒ Boolean): (Vector[A], Vector[A])

Split a sequence of things into two sequences, one with all the elements for which certain predicate holds, and one with the elements for which the predicate does not hold

def subSeq[A](a: Iterator[A], aFilter: Set[A], b: Iterator[A]): Boolean

Determine whether a occurs in b as a sub-sequence

def subSeq[A](a: Iterator[A], b: Iterator[A]): Boolean

Determine whether a occurs in b as a sub-sequence

final def synchronized[T0](arg0: ⇒ T0): T0

def toArray[A](els: Iterator[A])(implicit arg0: ClassTag[A]): Array[A]

def toStream[A](f: (Int) ⇒ A): Stream[A]

Lazily convert a function (over naturals) to a stream

def toString(): String

def tripleIterator[A](a: A, b: A, c: A): Iterator[A]

Iterator over exactly three elements

def union[A](sets: Iterator[Set[A]]): Set[A]

Compute union of a sequence of sets.

def union[A](sets: Iterable[Set[A]]): Set[A]

Compute union of a sequence of sets.

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit