com.twitter

algebird

package algebird

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. algebird
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. abstract class AbstractApplicative[M[_]] extends Applicative[M]

    For use from Java/minimizing code bloat in scala

  2. trait AbstractEventuallyAggregator[A, E, O, C] extends Aggregator[A, Either[E, O], C]

  3. abstract class AbstractFunctor[M[_]] extends Functor[M]

    For use from Java/minimizing code bloat in scala

  4. abstract class AbstractGroup[T] extends Group[T]

  5. abstract class AbstractMonad[M[_]] extends Monad[M]

    For use from Java/minimizing code bloat in scala

  6. abstract class AbstractMonoid[T] extends Monoid[T]

  7. abstract class AbstractRing[T] extends Ring[T]

  8. abstract class AbstractSemigroup[T] extends Semigroup[T]

  9. class AdaptiveCache[K, V] extends StatefulSummer[Map[K, V]]

    This is a wrapper around SummingCache that attempts to grow the capacity by up to some maximum, as long as there's enough RAM.

  10. sealed trait AdaptiveVector[V] extends IndexedSeq[V]

    An IndexedSeq that automatically switches representation between dense and sparse depending on sparsity Should be an efficient representation for all sizes, and it should not be necessary to special case immutable algebras based on the sparsity of the vectors.

  11. case class AdjoinedUnit[T](ones: BigInt, get: T) extends Product with Serializable

    This is for the case where your Ring[T] is a Rng (i.

  12. class AdjoinedUnitRing[T] extends Ring[AdjoinedUnit[T]]

  13. case class AffineFunction[R](slope: R, intercept: R) extends Serializable with Product with Serializable

    Represents functions of the kind: f(x) = slope * x + intercept

  14. class AffineFunctionMonoid[R] extends Monoid[AffineFunction[R]]

    This feeds the value in on the LEFT!!! This may seem counter intuitive, but with this approach, a stream/iterator which is summed will have the same output as applying the function one at a time in order to the input.

  15. trait Aggregator[-A, B, +C] extends Serializable

    This is a type that models map/reduce(map).

  16. class AggregatorApplicative[I] extends Applicative[[O]Aggregator[I, _, O]]

    Aggregators are Applicatives, but this hides the middle type.

  17. final case class AndVal(get: Boolean) extends AnyVal with Product with Serializable

  18. trait Applicative[M[_]] extends Functor[M]

    Simple implementation of an Applicative type-class.

  19. class ApplicativeGroup[T, M[_]] extends ApplicativeMonoid[T, M] with Group[M[T]]

    Group and Ring ARE NOT AUTOMATIC.

  20. class ApplicativeMonoid[T, M[_]] extends ApplicativeSemigroup[T, M] with Monoid[M[T]]

    This is a Monoid, for all Applicatives.

  21. class ApplicativeOperators[A, M[_]] extends FunctorOperators[A, M]

    This enrichment allows us to use our Applicative instances in for expressions: if (import Applicative.

  22. class ApplicativeRing[T, M[_]] extends ApplicativeGroup[T, M] with Ring[M[T]]

    Group and Ring ARE NOT AUTOMATIC.

  23. class ApplicativeSemigroup[T, M[_]] extends Semigroup[M[T]]

    This is a Semigroup, for all Applicatives.

  24. case class Approximate[N](min: N, estimate: N, max: N, probWithinBounds: Double)(implicit numeric: Numeric[N]) extends ApproximateSet[N] with Product with Serializable

  25. case class ApproximateBoolean(isTrue: Boolean, withProb: Double) extends ApproximateSet[Boolean] with Product with Serializable

  26. abstract class ArrayBufferedOperation[I, O] extends Buffered[I, O]

  27. class ArrayGroup[T] extends ArrayMonoid[T] with Group[Array[T]]

    Extends pair-wise sum Array monoid into a Group negate is defined as the negation of each element of the array.

  28. class ArrayMonoid[T] extends Monoid[Array[T]]

    Pair-wise sum Array monoid.

  29. case class AveragedValue(count: Long, value: Double) extends Product with Serializable

    Tracks the count and mean value of Doubles in a data stream.

  30. sealed abstract class BF[A] extends Serializable

    Bloom Filter data structure

  31. case class BFHash[A](numHashes: Int, width: Int)(implicit hash: Hash128[A]) extends Product with Serializable

  32. case class BFInstance[A](hashes: BFHash[A], bits: BitSet, width: Int) extends BF[A] with Product with Serializable

  33. case class BFItem[A](item: A, hashes: BFHash[A], width: Int) extends BF[A] with Product with Serializable

    Bloom Filter with 1 value.

  34. case class BFSparse[A](hashes: BFHash[A], bits: EWAHCompressedBitmap, width: Int) extends BF[A] with Product with Serializable

  35. case class BFZero[A](hashes: BFHash[A], width: Int) extends BF[A] with Product with Serializable

    Empty bloom filter.

  36. sealed abstract class Batched[T] extends Serializable

    Batched: the free semigroup.

  37. class BatchedMonoid[T] extends BatchedSemigroup[T] with Monoid[Batched[T]]

    Compacting monoid for batched values.

  38. class BatchedSemigroup[T] extends Semigroup[Batched[T]]

    Compacting semigroup for batched values.

  39. case class BloomFilterAggregator[A](bfMonoid: BloomFilterMonoid[A]) extends MonoidAggregator[A, BF[A], BF[A]] with Product with Serializable

  40. case class BloomFilterMonoid[A](numHashes: Int, width: Int)(implicit hash: Hash128[A]) extends Monoid[BF[A]] with BoundedSemilattice[BF[A]] with Product with Serializable

    Bloom Filter - a probabilistic data structure to test presence of an element.

  41. trait Buffered[I, O] extends Serializable

    Represents something that consumes I and may emit O.

  42. trait BufferedReduce[V] extends Buffered[V, V]

    This never emits on put, you must call flush designed to be use in the stackable pattern with ArrayBufferedOperation

  43. class BufferedSumAll[V] extends ArrayBufferedOperation[V, V] with StatefulSummer[V] with BufferedReduce[V]

  44. final case class Bytes(array: Array[Byte]) extends Serializable with Product with Serializable

    A wrapper for Array[Byte] that provides sane implementations of hashCode, equals, and toString.

  45. sealed abstract class CMS[K] extends Serializable with CMSCounting[K, CMS]

    A Count-Min sketch data structure that allows for counting and frequency estimation of elements in a data stream.

  46. case class CMSAggregator[K](cmsMonoid: CMSMonoid[K]) extends MonoidAggregator[K, CMS[K], CMS[K]] with Product with Serializable

    An Aggregator for CMS.

  47. trait CMSCounting[K, C[_]] extends AnyRef

    A trait for CMS implementations that can count elements in a data stream and that can answer point queries (i.

  48. case class CMSHash[K](a: Int, b: Int, width: Int)(implicit evidence$30: CMSHasher[K]) extends Serializable with Product with Serializable

  49. trait CMSHasher[K] extends Serializable

    The Count-Min sketch uses d (aka depth) pair-wise independent hash functions drawn from a universal hashing family of the form:

  50. trait CMSHeavyHitters[K] extends AnyRef

    A trait for CMS implementations that can track heavy hitters in a data stream.

  51. case class CMSInstance[K](countsTable: CountsTable[K], totalCount: Long, params: CMSParams[K]) extends CMS[K] with Product with Serializable

    The general Count-Min sketch structure, used for holding any number of elements.

  52. case class CMSItem[K](item: K, totalCount: Long, params: CMSParams[K]) extends CMS[K] with Product with Serializable

    Used for holding a single element, to avoid repeatedly adding elements from sparse counts tables.

  53. class CMSMonoid[K] extends Monoid[CMS[K]] with CommutativeMonoid[CMS[K]]

    Monoid for adding CMS sketches.

  54. case class CMSParams[K](hashes: Seq[CMSHash[K]], eps: Double, delta: Double, maxExactCountOpt: Option[Int] = scala.None) extends Product with Serializable

    Configuration parameters for CMS.

  55. class CMSSummation[K] extends AnyRef

    This mutable builder can be used when speed is essential and you can be sure the scope of the mutability cannot escape in an unsafe way.

  56. case class CMSZero[K](params: CMSParams[K]) extends CMS[K] with Product with Serializable

    Zero element.

  57. class CassandraMurmurHash extends AnyRef

  58. class ConstantGroup[T] extends Group[T]

  59. case class DecayedValue(value: Double, scaledTime: Double) extends Ordered[DecayedValue] with Product with Serializable

  60. case class DecayedValueMonoid(eps: Double) extends Monoid[DecayedValue] with Product with Serializable

  61. case class DecayedVector[C[_]](vector: C[Double], scaledTime: Double) extends Product with Serializable

  62. case class DenseHLL(bits: Int, v: Bytes) extends HLL with Product with Serializable

    These are the individual instances which the Monoid knows how to add

  63. case class DenseVector[V](iseq: Vector[V], sparseValue: V, denseCount: Int) extends AdaptiveVector[V] with Product with Serializable

  64. class EitherMonoid[L, R] extends EitherSemigroup[L, R] with Monoid[Either[L, R]]

  65. class EitherSemigroup[L, R] extends Semigroup[Either[L, R]]

    Either semigroup is useful for error handling.

  66. case class Empty[T]() extends Interval[T] with Product with Serializable

  67. trait EventuallyAggregator[A, E, O, C] extends AbstractEventuallyAggregator[A, E, O, C]

  68. class EventuallyGroup[E, O] extends EventuallyMonoid[E, O] with Group[Either[E, O]]

  69. class EventuallyMonoid[E, O] extends EventuallySemigroup[E, O] with Monoid[Either[E, O]]

  70. trait EventuallyMonoidAggregator[A, E, O, C] extends AbstractEventuallyAggregator[A, E, O, C] with MonoidAggregator[A, Either[E, O], C]

  71. class EventuallyRing[E, O] extends EventuallyGroup[E, O] with Ring[Either[E, O]]

  72. class EventuallySemigroup[E, O] extends Semigroup[Either[E, O]]

    Classes that support algebraic structures with dynamic switching between two representations, the original type O and the eventual type E.

  73. case class ExclusiveLower[T](lower: T) extends Interval[T] with Lower[T] with Product with Serializable

  74. case class ExclusiveUpper[T](upper: T) extends Interval[T] with Upper[T] with Product with Serializable

  75. case class ExpHist(conf: Config, buckets: Vector[Bucket], total: Long, time: Timestamp) extends Product with Serializable

    Exponential Histogram algorithm from http://www-cs-students.

  76. type Field[V] = algebra.ring.Field[V]

    To keep code using algebird.

    To keep code using algebird.Field compiling, we export algebra Field

  77. case class First[+T](get: T) extends Product with Serializable

    Tracks the "least recent", or earliest, wrapped instance of T by the order in which items are seen.

  78. case class FirstAggregator[T]() extends Aggregator[T, T, T] with Product with Serializable

    Aggregator that selects the first instance of T in the aggregated stream.

  79. trait FlatMapPreparer[A, T] extends Preparer[A, T]

    A Preparer that has had one or more flatMap operations applied.

  80. sealed trait Fold[-I, +O] extends Serializable

    Folds are first-class representations of "Traversable.

  81. class FoldApplicative[I] extends Applicative[[O]Fold[I, O]]

    Folds are Applicatives!

  82. final class FoldState[X, -I, +O] extends Serializable

    A FoldState defines a left fold with a "hidden" accumulator type.

  83. class FromAlgebraGroup[T] extends FromAlgebraMonoid[T] with Group[T]

  84. class FromAlgebraMonoid[T] extends FromAlgebraSemigroup[T] with Monoid[T]

  85. class FromAlgebraRing[T] extends Ring[T]

  86. class FromAlgebraSemigroup[T] extends Semigroup[T]

  87. class Function1Monoid[T] extends Monoid[(T) ⇒ T]

    Function1 monoid.

  88. trait Functor[M[_]] extends AnyRef

    Simple implementation of a Functor type-class.

  89. class FunctorOperators[A, M[_]] extends AnyRef

    This enrichment allows us to use our Functor instances in for expressions: if (import Functor.

  90. case class GenHLLAggregator[K](hllMonoid: HyperLogLogMonoid, hash: Hash128[K]) extends MonoidAggregator[K, HLL, HLL] with Product with Serializable

  91. trait GeneratedGroupImplicits extends AnyRef

  92. trait GeneratedMonoidImplicits extends AnyRef

  93. trait GeneratedRingImplicits extends AnyRef

  94. trait GeneratedSemigroupImplicits extends AnyRef

  95. trait GeneratedTupleAggregator extends AnyRef

  96. abstract class GenericMapMonoid[K, V, M <: Map[K, V]] extends Monoid[M] with MapOperations[K, V, M]

  97. trait GenericMapRing[K, V, M <: Map[K, V]] extends Rng[M] with MapOperations[K, V, M]

    You can think of this as a Sparse vector ring

  98. trait Group[T] extends algebra.Group[T] with Monoid[T] with AdditiveGroup[T]

    Group: this is a monoid that also has subtraction (and negation): So, you can do (a-b), or -a (which is equal to 0 - a).

  99. sealed abstract class HLL extends Serializable

  100. case class HLLSeries(bits: Int, rows: Vector[Map[Int, Long]]) extends Product with Serializable

    HLLSeries can produce a HyperLogLog counter for any window into the past, using a constant factor more space than HyperLogLog.

  101. trait Hash128[-K] extends Serializable

    A typeclass to represent hashing to 128 bits.

  102. class HashingTrickMonoid[V] extends Monoid[AdaptiveVector[V]]

  103. case class HeavyHitter[K](item: K, count: Long) extends Serializable with Product with Serializable

  104. case class HeavyHitters[K](hhs: Set[HeavyHitter[K]]) extends Serializable with Product with Serializable

    Containers for holding heavy hitter items and their associated counts.

  105. abstract class HeavyHittersLogic[K] extends Serializable

    Controls how a CMS that implements CMSHeavyHitters tracks heavy hitters.

  106. case class HyperLogLogAggregator(hllMonoid: HyperLogLogMonoid) extends MonoidAggregator[Array[Byte], HLL, HLL] with Product with Serializable

  107. class HyperLogLogMonoid extends Monoid[HLL] with BoundedSemilattice[HLL]

  108. class HyperLogLogSeriesMonoid extends Monoid[HLLSeries]

    val hllSeriesMonoid = new HyperLogLogSeriesMonoid(bits)

  109. case class Identity[T](get: T) extends Product with Serializable

  110. case class InclusiveLower[T](lower: T) extends Interval[T] with Lower[T] with Product with Serializable

  111. case class InclusiveUpper[T](upper: T) extends Interval[T] with Upper[T] with Product with Serializable

  112. class IndexedSeqGroup[T] extends IndexedSeqMonoid[T] with Group[IndexedSeq[T]]

  113. class IndexedSeqMonoid[T] extends IndexedSeqSemigroup[T] with Monoid[IndexedSeq[T]]

  114. class IndexedSeqRing[T] extends IndexedSeqGroup[T] with Ring[IndexedSeq[T]]

  115. class IndexedSeqSemigroup[T] extends Semigroup[IndexedSeq[T]]

    Note that this works similar to Semigroup[Map[Int,T]] not like Semigroup[List[T]] This does element-wise operations, like standard vector math, not concatenation, like Semigroup[String] or Semigroup[List[T]]

  116. class IntegralPredecessible[T] extends Predecessible[T]

  117. class IntegralSuccessible[T] extends Successible[T]

  118. case class Intersection[L[t] <: Lower[t], U[t] <: Upper[t], T](lower: L[T], upper: U[T]) extends Interval[T] with Product with Serializable

  119. sealed trait Interval[T] extends Serializable

    Represents a single interval on a T with an Ordering

  120. class JListMonoid[T] extends Monoid[List[T]]

    Since Lists are mutable, this always makes a full copy.

  121. class JMapMonoid[K, V] extends Monoid[Map[K, V]]

    Since maps are mutable, this always makes a full copy.

  122. case class Last[+T](get: T) extends Product with Serializable

    Tracks the "most recent", or last, wrapped instance of T by the order in which items are seen.

  123. case class LastAggregator[T]() extends Aggregator[T, T, T] with Product with Serializable

    Aggregator that selects the last instance of T in the aggregated stream.

  124. class ListMonoid[T] extends Monoid[List[T]]

    List concatenation monoid.

  125. sealed trait Lower[T] extends Interval[T]

  126. trait MapAggregator[A, B, K, C] extends Aggregator[A, B, Map[K, C]]

  127. class MapGroup[K, V] extends MapMonoid[K, V] with Group[Map[K, V]]

    You can think of this as a Sparse vector group

  128. class MapMonoid[K, V] extends GenericMapMonoid[K, V, Map[K, V]]

  129. trait MapMonoidAggregator[A, B, K, C] extends MonoidAggregator[A, B, Map[K, C]]

  130. trait MapOperations[K, V, M <: Map[K, V]] extends AnyRef

  131. trait MapPreparer[A, T] extends Preparer[A, T]

    A Preparer that has had zero or more map transformations applied, but no flatMaps.

  132. class MapRing[K, V] extends MapGroup[K, V] with GenericMapRing[K, V, Map[K, V]]

  133. case class Max[+T](get: T) extends Product with Serializable

    Tracks the maximum wrapped instance of some ordered type T.

  134. case class MaxAggregator[T]()(implicit ord: Ordering[T]) extends Aggregator[T, T, T] with Product with Serializable

    Aggregator that selects the maximum instance of T in the aggregated stream.

  135. trait Metric[-V] extends Serializable

    Annotations
    @implicitNotFound( ... )
  136. case class Min[+T](get: T) extends Product with Serializable

    Tracks the minimum wrapped instance of some ordered type T.

  137. case class MinAggregator[T]()(implicit ord: Ordering[T]) extends Aggregator[T, T, T] with Product with Serializable

    Aggregator that selects the minimum instance of T in the aggregated stream.

  138. final case class MinHashSignature(bytes: Array[Byte]) extends AnyVal with Product with Serializable

    MinHasher as a Monoid operates on this class to avoid the too generic Array[Byte].

  139. abstract class MinHasher[H] extends Monoid[MinHashSignature]

    Instances of MinHasher can create, combine, and compare fixed-sized signatures of arbitrarily sized sets.

  140. class MinHasher16 extends MinHasher[Char]

  141. class MinHasher32 extends MinHasher[Int]

  142. sealed trait MinPlus[+V] extends Serializable

  143. class MinPlusSemiring[V] extends Rig[MinPlus[V]]

  144. final case class MinPlusValue[V](get: V) extends AnyVal with MinPlus[V] with Product with Serializable

  145. class MinusOp[T] extends AnyRef

  146. case class Moments(m0: Long, m1: Double, m2: Double, m3: Double, m4: Double) extends Product with Serializable

    A class to calculate the first five central moments over a sequence of Doubles.

  147. trait Monad[M[_]] extends Applicative[M]

    Simple implementation of a Monad type-class.

  148. class MonadOperators[A, M[_]] extends ApplicativeOperators[A, M]

    This enrichment allows us to use our Monad instances in for expressions: if (import Monad.

  149. trait Monoid[T] extends Semigroup[T] with algebra.Monoid[T] with AdditiveMonoid[T]

    Monoid (take a deep breath, and relax about the weird name): This is a semigroup that has an additive identity (called zero), such that a+0=a, 0+a=a, for every a

  150. trait MonoidAggregator[-A, B, +C] extends Aggregator[A, B, C]

  151. class MonoidCombinator[A, B] extends SemigroupCombinator[A, B] with Monoid[(A, B)]

  152. final case class MurmurHash128(seed: Long) extends AnyVal with Product with Serializable

  153. class NumericRing[T] extends Ring[T]

  154. trait NumericRingProvider extends AnyRef

  155. class OptionGroup[T] extends OptionMonoid[T] with Group[Option[T]]

    Some(5) - Some(3) == Some(2) Some(5) - Some(5) == None negate Some(5) == Some(-5) Note: Some(0) and None are equivalent under this Group

  156. class OptionMonoid[T] extends Monoid[Option[T]]

    Some(5) + Some(3) == Some(8) Some(5) + None == Some(5)

  157. final case class OrVal(get: Boolean) extends AnyVal with Product with Serializable

  158. class PlusOp[T] extends AnyRef

  159. trait Predecessible[T] extends Serializable

    This is a typeclass to represent things which are countable down.

  160. sealed trait Preparer[A, T] extends Serializable

    Preparer is a way to build up an Aggregator through composition using a more natural API: it allows you to start with the input type and describe a series of transformations and aggregations from there, rather than starting from the aggregation and composing "outwards" in both directions.

  161. sealed trait Priority[+P, +F] extends AnyRef

    Priority is a type class for prioritized implicit search.

  162. class Product10Group[X, A, B, C, D, E, F, G, H, I, J] extends Product10Monoid[X, A, B, C, D, E, F, G, H, I, J] with Group[X]

    Combine 10 groups into a product group

  163. class Product10Monoid[X, A, B, C, D, E, F, G, H, I, J] extends Product10Semigroup[X, A, B, C, D, E, F, G, H, I, J] with Monoid[X]

    Combine 10 monoids into a product monoid

  164. class Product10Ring[X, A, B, C, D, E, F, G, H, I, J] extends Product10Group[X, A, B, C, D, E, F, G, H, I, J] with Ring[X]

    Combine 10 rings into a product ring

  165. class Product10Semigroup[X, A, B, C, D, E, F, G, H, I, J] extends Semigroup[X]

    Combine 10 semigroups into a product semigroup

  166. class Product11Group[X, A, B, C, D, E, F, G, H, I, J, K] extends Product11Monoid[X, A, B, C, D, E, F, G, H, I, J, K] with Group[X]

    Combine 11 groups into a product group

  167. class Product11Monoid[X, A, B, C, D, E, F, G, H, I, J, K] extends Product11Semigroup[X, A, B, C, D, E, F, G, H, I, J, K] with Monoid[X]

    Combine 11 monoids into a product monoid

  168. class Product11Ring[X, A, B, C, D, E, F, G, H, I, J, K] extends Product11Group[X, A, B, C, D, E, F, G, H, I, J, K] with Ring[X]

    Combine 11 rings into a product ring

  169. class Product11Semigroup[X, A, B, C, D, E, F, G, H, I, J, K] extends Semigroup[X]

    Combine 11 semigroups into a product semigroup

  170. class Product12Group[X, A, B, C, D, E, F, G, H, I, J, K, L] extends Product12Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L] with Group[X]

    Combine 12 groups into a product group

  171. class Product12Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L] extends Product12Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L] with Monoid[X]

    Combine 12 monoids into a product monoid

  172. class Product12Ring[X, A, B, C, D, E, F, G, H, I, J, K, L] extends Product12Group[X, A, B, C, D, E, F, G, H, I, J, K, L] with Ring[X]

    Combine 12 rings into a product ring

  173. class Product12Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L] extends Semigroup[X]

    Combine 12 semigroups into a product semigroup

  174. class Product13Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M] extends Product13Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M] with Group[X]

    Combine 13 groups into a product group

  175. class Product13Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M] extends Product13Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M] with Monoid[X]

    Combine 13 monoids into a product monoid

  176. class Product13Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M] extends Product13Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M] with Ring[X]

    Combine 13 rings into a product ring

  177. class Product13Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M] extends Semigroup[X]

    Combine 13 semigroups into a product semigroup

  178. class Product14Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Product14Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N] with Group[X]

    Combine 14 groups into a product group

  179. class Product14Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Product14Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N] with Monoid[X]

    Combine 14 monoids into a product monoid

  180. class Product14Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Product14Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N] with Ring[X]

    Combine 14 rings into a product ring

  181. class Product14Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Semigroup[X]

    Combine 14 semigroups into a product semigroup

  182. class Product15Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Product15Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] with Group[X]

    Combine 15 groups into a product group

  183. class Product15Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Product15Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] with Monoid[X]

    Combine 15 monoids into a product monoid

  184. class Product15Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Product15Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] with Ring[X]

    Combine 15 rings into a product ring

  185. class Product15Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Semigroup[X]

    Combine 15 semigroups into a product semigroup

  186. class Product16Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Product16Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] with Group[X]

    Combine 16 groups into a product group

  187. class Product16Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Product16Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] with Monoid[X]

    Combine 16 monoids into a product monoid

  188. class Product16Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Product16Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] with Ring[X]

    Combine 16 rings into a product ring

  189. class Product16Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Semigroup[X]

    Combine 16 semigroups into a product semigroup

  190. class Product17Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Product17Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] with Group[X]

    Combine 17 groups into a product group

  191. class Product17Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Product17Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] with Monoid[X]

    Combine 17 monoids into a product monoid

  192. class Product17Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Product17Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] with Ring[X]

    Combine 17 rings into a product ring

  193. class Product17Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Semigroup[X]

    Combine 17 semigroups into a product semigroup

  194. class Product18Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Product18Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] with Group[X]

    Combine 18 groups into a product group

  195. class Product18Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Product18Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] with Monoid[X]

    Combine 18 monoids into a product monoid

  196. class Product18Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Product18Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] with Ring[X]

    Combine 18 rings into a product ring

  197. class Product18Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Semigroup[X]

    Combine 18 semigroups into a product semigroup

  198. class Product19Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Product19Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] with Group[X]

    Combine 19 groups into a product group

  199. class Product19Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Product19Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] with Monoid[X]

    Combine 19 monoids into a product monoid

  200. class Product19Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Product19Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] with Ring[X]

    Combine 19 rings into a product ring

  201. class Product19Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Semigroup[X]

    Combine 19 semigroups into a product semigroup

  202. class Product20Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Product20Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] with Group[X]

    Combine 20 groups into a product group

  203. class Product20Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Product20Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] with Monoid[X]

    Combine 20 monoids into a product monoid

  204. class Product20Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Product20Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] with Ring[X]

    Combine 20 rings into a product ring

  205. class Product20Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Semigroup[X]

    Combine 20 semigroups into a product semigroup

  206. class Product21Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Product21Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] with Group[X]

    Combine 21 groups into a product group

  207. class Product21Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Product21Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] with Monoid[X]

    Combine 21 monoids into a product monoid

  208. class Product21Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Product21Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] with Ring[X]

    Combine 21 rings into a product ring

  209. class Product21Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Semigroup[X]

    Combine 21 semigroups into a product semigroup

  210. class Product22Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Product22Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] with Group[X]

    Combine 22 groups into a product group

  211. class Product22Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Product22Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] with Monoid[X]

    Combine 22 monoids into a product monoid

  212. class Product22Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Product22Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] with Ring[X]

    Combine 22 rings into a product ring

  213. class Product22Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Semigroup[X]

    Combine 22 semigroups into a product semigroup

  214. class Product2Group[X, A, B] extends Product2Monoid[X, A, B] with Group[X]

    Combine 2 groups into a product group

  215. class Product2Monoid[X, A, B] extends Product2Semigroup[X, A, B] with Monoid[X]

    Combine 2 monoids into a product monoid

  216. class Product2Ring[X, A, B] extends Product2Group[X, A, B] with Ring[X]

    Combine 2 rings into a product ring

  217. class Product2Semigroup[X, A, B] extends Semigroup[X]

    Combine 2 semigroups into a product semigroup

  218. class Product3Group[X, A, B, C] extends Product3Monoid[X, A, B, C] with Group[X]

    Combine 3 groups into a product group

  219. class Product3Monoid[X, A, B, C] extends Product3Semigroup[X, A, B, C] with Monoid[X]

    Combine 3 monoids into a product monoid

  220. class Product3Ring[X, A, B, C] extends Product3Group[X, A, B, C] with Ring[X]

    Combine 3 rings into a product ring

  221. class Product3Semigroup[X, A, B, C] extends Semigroup[X]

    Combine 3 semigroups into a product semigroup

  222. class Product4Group[X, A, B, C, D] extends Product4Monoid[X, A, B, C, D] with Group[X]

    Combine 4 groups into a product group

  223. class Product4Monoid[X, A, B, C, D] extends Product4Semigroup[X, A, B, C, D] with Monoid[X]

    Combine 4 monoids into a product monoid

  224. class Product4Ring[X, A, B, C, D] extends Product4Group[X, A, B, C, D] with Ring[X]

    Combine 4 rings into a product ring

  225. class Product4Semigroup[X, A, B, C, D] extends Semigroup[X]

    Combine 4 semigroups into a product semigroup

  226. class Product5Group[X, A, B, C, D, E] extends Product5Monoid[X, A, B, C, D, E] with Group[X]

    Combine 5 groups into a product group

  227. class Product5Monoid[X, A, B, C, D, E] extends Product5Semigroup[X, A, B, C, D, E] with Monoid[X]

    Combine 5 monoids into a product monoid

  228. class Product5Ring[X, A, B, C, D, E] extends Product5Group[X, A, B, C, D, E] with Ring[X]

    Combine 5 rings into a product ring

  229. class Product5Semigroup[X, A, B, C, D, E] extends Semigroup[X]

    Combine 5 semigroups into a product semigroup

  230. class Product6Group[X, A, B, C, D, E, F] extends Product6Monoid[X, A, B, C, D, E, F] with Group[X]

    Combine 6 groups into a product group

  231. class Product6Monoid[X, A, B, C, D, E, F] extends Product6Semigroup[X, A, B, C, D, E, F] with Monoid[X]

    Combine 6 monoids into a product monoid

  232. class Product6Ring[X, A, B, C, D, E, F] extends Product6Group[X, A, B, C, D, E, F] with Ring[X]

    Combine 6 rings into a product ring

  233. class Product6Semigroup[X, A, B, C, D, E, F] extends Semigroup[X]

    Combine 6 semigroups into a product semigroup

  234. class Product7Group[X, A, B, C, D, E, F, G] extends Product7Monoid[X, A, B, C, D, E, F, G] with Group[X]

    Combine 7 groups into a product group

  235. class Product7Monoid[X, A, B, C, D, E, F, G] extends Product7Semigroup[X, A, B, C, D, E, F, G] with Monoid[X]

    Combine 7 monoids into a product monoid

  236. class Product7Ring[X, A, B, C, D, E, F, G] extends Product7Group[X, A, B, C, D, E, F, G] with Ring[X]

    Combine 7 rings into a product ring

  237. class Product7Semigroup[X, A, B, C, D, E, F, G] extends Semigroup[X]

    Combine 7 semigroups into a product semigroup

  238. class Product8Group[X, A, B, C, D, E, F, G, H] extends Product8Monoid[X, A, B, C, D, E, F, G, H] with Group[X]

    Combine 8 groups into a product group

  239. class Product8Monoid[X, A, B, C, D, E, F, G, H] extends Product8Semigroup[X, A, B, C, D, E, F, G, H] with Monoid[X]

    Combine 8 monoids into a product monoid

  240. class Product8Ring[X, A, B, C, D, E, F, G, H] extends Product8Group[X, A, B, C, D, E, F, G, H] with Ring[X]

    Combine 8 rings into a product ring

  241. class Product8Semigroup[X, A, B, C, D, E, F, G, H] extends Semigroup[X]

    Combine 8 semigroups into a product semigroup

  242. class Product9Group[X, A, B, C, D, E, F, G, H, I] extends Product9Monoid[X, A, B, C, D, E, F, G, H, I] with Group[X]

    Combine 9 groups into a product group

  243. class Product9Monoid[X, A, B, C, D, E, F, G, H, I] extends Product9Semigroup[X, A, B, C, D, E, F, G, H, I] with Monoid[X]

    Combine 9 monoids into a product monoid

  244. class Product9Ring[X, A, B, C, D, E, F, G, H, I] extends Product9Group[X, A, B, C, D, E, F, G, H, I] with Ring[X]

    Combine 9 rings into a product ring

  245. class Product9Semigroup[X, A, B, C, D, E, F, G, H, I] extends Semigroup[X]

    Combine 9 semigroups into a product semigroup

  246. trait ProductGroups extends AnyRef

  247. trait ProductMonoids extends AnyRef

  248. trait ProductRings extends AnyRef

  249. trait ProductSemigroups extends AnyRef

  250. final class PureOp[A] extends AnyVal

  251. class QTree[A] extends Product6[Long, Int, Long, A, Option[QTree[A]], Option[QTree[A]]] with Serializable

  252. case class QTreeAggregator[T](percentile: Double, k: Int = QTreeAggregator.DefaultK)(implicit num: Numeric[T]) extends Aggregator[T, QTree[Unit], Intersection[InclusiveLower, InclusiveUpper, Double]] with QTreeAggregatorLike[T] with Product with Serializable

    QTree aggregator is an aggregator that can be used to find the approximate percentile bounds.

  253. trait QTreeAggregatorLike[T] extends AnyRef

  254. case class QTreeAggregatorLowerBound[T](percentile: Double, k: Int = QTreeAggregator.DefaultK)(implicit num: Numeric[T]) extends Aggregator[T, QTree[Unit], Double] with QTreeAggregatorLike[T] with Product with Serializable

    QTreeAggregatorLowerBound is an aggregator that is used to find an appoximate percentile.

  255. class QTreeSemigroup[A] extends Semigroup[QTree[A]]

  256. sealed trait ResetState[+A] extends AnyRef

    Used to represent cases where we need to periodically reset a + b = a + b |a + b = |(a + b) a + |b = |b |a + |b = |b

  257. class ResetStateMonoid[A] extends Monoid[ResetState[A]]

  258. case class ResetValue[+A](get: A) extends ResetState[A] with Product with Serializable

  259. final class RichCBitSet extends AnyVal

  260. class RichTraversable[T] extends AnyRef

  261. sealed abstract class RightFolded[+In, +Out] extends AnyRef

  262. sealed abstract class RightFolded2[+In, +Out, +Acc] extends AnyRef

  263. class RightFolded2Monoid[In, Out, Acc] extends Monoid[RightFolded2[In, Out, Acc]]

  264. case class RightFoldedToFold[+In](in: List[In]) extends RightFolded[In, Nothing] with Product with Serializable

  265. case class RightFoldedToFold2[+In](in: List[In]) extends RightFolded2[In, Nothing, Nothing] with Product with Serializable

  266. case class RightFoldedValue[+Out](v: Out) extends RightFolded[Nothing, Out] with Product with Serializable

  267. case class RightFoldedValue2[+In, +Out, +Acc](v: Out, acc: Acc, rvals: List[In]) extends RightFolded2[In, Out, Acc] with Product with Serializable

  268. trait Ring[T] extends Group[T] with CommutativeGroup[T] with algebra.ring.Ring[T]

    Ring: Group + multiplication (see: http://en.

  269. trait RingAggregator[-A, B, +C] extends MonoidAggregator[A, B, C]

  270. sealed abstract class SGD[+Pos] extends AnyRef

  271. class SGDMonoid[Pos] extends Monoid[SGD[Pos]]

    Basically a specific implementation of the RightFoldedMonoid gradient is the gradient of the function to be minimized To use this, you need to insert an initial weight SGDWeights before you start adding SGDPos objects.

  272. case class SGDPos[+Pos](pos: List[Pos]) extends SGD[Pos] with Product with Serializable

  273. case class SGDWeights(count: Long, weights: IndexedSeq[Double]) extends SGD[Nothing] with Product with Serializable

  274. case class SSMany[T] extends SpaceSaver[T] with Product with Serializable

  275. case class SSOne[T] extends SpaceSaver[T] with Product with Serializable

  276. class ScMapGroup[K, V] extends ScMapMonoid[K, V] with Group[Map[K, V]]

  277. class ScMapMonoid[K, V] extends GenericMapMonoid[K, V, Map[K, V]]

  278. class ScMapRing[K, V] extends ScMapGroup[K, V] with GenericMapRing[K, V, Map[K, V]]

  279. class ScopedTopNCMSMonoid[K1, K2] extends TopCMSMonoid[(K1, K2)]

  280. case class ScopedTopNLogic[K1, K2](heavyHittersN: Int) extends HeavyHittersLogic[(K1, K2)] with Product with Serializable

    K1 defines a scope for the CMS.

  281. trait Semigroup[T] extends algebra.Semigroup[T] with AdditiveSemigroup[T]

    A semigroup is any type T with an associative operation (plus):

  282. class SemigroupCombinator[A, B] extends Semigroup[(A, B)]

    This is a combinator on semigroups, after you do the plus, you transform B with a fold function This will not be valid for all fold functions.

  283. class SentinelCache[K, V] extends AnyRef

    This is a summing cache whose goal is to grow until we run out of memory, at which point it clears itself and stops growing.

  284. class SeqMonoid[T] extends Monoid[Seq[T]]

  285. sealed abstract case class SetDiff[T] extends Product with Serializable

    SetDiff is a class that represents changes applied to a set.

  286. class SetMonoid[T] extends Monoid[Set[T]]

    Set union monoid.

  287. case class SetSizeAggregator[A](hllBits: Int, maxSetSize: Int = 10)(implicit toBytes: (A) ⇒ Array[Byte]) extends SetSizeAggregatorBase[A] with Product with Serializable

  288. abstract class SetSizeAggregatorBase[A] extends EventuallyMonoidAggregator[A, HLL, Set[A], Long]

    convert is not not implemented here

  289. case class SetSizeHashAggregator[A](hllBits: Int, maxSetSize: Int = 10)(implicit hash: Hash128[A]) extends SetSizeAggregatorBase[A] with Product with Serializable

    Use a Hash128 when converting to HLL, rather than an implicit conversion to Array[Byte] Unifying with SetSizeAggregator would be nice, but since they only differ in an implicit parameter, scala seems to be giving me errors.

  290. case class SetValue[+A](get: A) extends ResetState[A] with Product with Serializable

  291. case class SketchMap[K, V](valuesTable: AdaptiveMatrix[V], heavyHitterKeys: List[K], totalValue: V) extends Serializable with Product with Serializable

  292. case class SketchMapAggregator[K, V](params: SketchMapParams[K], skmMonoid: SketchMapMonoid[K, V])(implicit valueOrdering: Ordering[V], valueMonoid: Monoid[V]) extends MonoidAggregator[(K, V), SketchMap[K, V], SketchMap[K, V]] with Product with Serializable

    An Aggregator for the SketchMap.

  293. case class SketchMapHash[K](hasher: CMSHash[Long], seed: Int)(implicit serialization: (K) ⇒ Array[Byte]) extends Product with Serializable

    Hashes an arbitrary key type to one that the Sketch Map can use.

  294. class SketchMapMonoid[K, V] extends Monoid[SketchMap[K, V]] with CommutativeMonoid[SketchMap[K, V]]

    Responsible for creating instances of SketchMap.

  295. case class SketchMapParams[K](seed: Int, width: Int, depth: Int, heavyHittersCount: Int)(implicit serialization: (K) ⇒ Array[Byte]) extends Product with Serializable

    Convenience class for holding constant parameters of a Sketch Map.

  296. sealed abstract class SpaceSaver[T] extends AnyRef

    Data structure used in the Space-Saving Algorithm to find the approximate most frequent and top-k elements.

  297. class SpaceSaverSemigroup[T] extends Semigroup[SpaceSaver[T]]

  298. case class SparseCMS[K](exactCountTable: Map[K, Long], totalCount: Long, params: CMSParams[K]) extends CMS[K] with Product with Serializable

    A sparse Count-Min sketch structure, used for situations where the key is highly skewed.

  299. case class SparseHLL(bits: Int, maxRhow: Map[Int, Max[Byte]]) extends HLL with Product with Serializable

  300. case class SparseVector[V](map: Map[Int, V], sparseValue: V, size: Int) extends AdaptiveVector[V] with Product with Serializable

  301. trait StatefulSummer[V] extends Buffered[V, V]

    A Stateful summer is something that is potentially more efficient (a buffer, a cache, etc.

  302. trait Successible[T] extends Serializable

    This is a typeclass to represent things which increase.

  303. class SumAll[V] extends StatefulSummer[V]

    Sum the entire iterator one item at a time.

  304. class SummingCache[K, V] extends StatefulSummer[Map[K, V]]

    A Stateful Summer on Map[K,V] that keeps a cache of recent keys

  305. class SummingIterator[V] extends Serializable with Iterator[V]

  306. class SummingQueue[V] extends StatefulSummer[V]

  307. class SummingWithHitsCache[K, V] extends SummingCache[K, V]

    A SummingCache that also tracks the number of key hits

  308. class TimesOp[T] extends AnyRef

  309. sealed abstract class TopCMS[K] extends Serializable with CMSCounting[K, TopCMS] with CMSHeavyHitters[K]

    A Count-Min sketch data structure that allows for (a) counting and frequency estimation of elements in a data stream and (b) tracking the heavy hitters among these elements.

  310. class TopCMSAggregator[K] extends MonoidAggregator[K, TopCMS[K], TopCMS[K]]

  311. case class TopCMSInstance[K](cms: CMS[K], hhs: HeavyHitters[K], params: TopCMSParams[K]) extends TopCMS[K] with Product with Serializable

  312. case class TopCMSItem[K](item: K, cms: CMS[K], params: TopCMSParams[K]) extends TopCMS[K] with Product with Serializable

    Used for holding a single element, to avoid repeatedly adding elements from sparse counts tables.

  313. class TopCMSMonoid[K] extends Monoid[TopCMS[K]]

  314. case class TopCMSParams[K](logic: HeavyHittersLogic[K]) extends Product with Serializable

  315. case class TopCMSZero[K](cms: CMS[K], params: TopCMSParams[K]) extends TopCMS[K] with Product with Serializable

    Zero element.

  316. case class TopK[N](size: Int, items: List[N], max: Option[N]) extends Product with Serializable

  317. class TopKMonoid[T] extends Monoid[TopK[T]]

    A top-k monoid that is much faster than SortedListTake equivalent to: (left ++ right).

  318. class TopKToListAggregator[A] extends MonoidAggregator[A, TopK[A], List[A]]

  319. case class TopNCMSAggregator[K](cmsMonoid: TopNCMSMonoid[K]) extends TopCMSAggregator[K] with Product with Serializable

    An Aggregator for TopNCMS.

  320. class TopNCMSMonoid[K] extends TopCMSMonoid[K]

    Monoid for top-N based TopCMS sketches.

  321. case class TopNLogic[K](heavyHittersN: Int) extends HeavyHittersLogic[K] with Product with Serializable

    Tracks the top N heavy hitters, where N is defined by heavyHittersN.

  322. case class TopPctCMSAggregator[K](cmsMonoid: TopPctCMSMonoid[K]) extends TopCMSAggregator[K] with Product with Serializable

    An Aggregator for TopPctCMS.

  323. class TopPctCMSMonoid[K] extends TopCMSMonoid[K]

    Monoid for Top-% based TopCMS sketches.

  324. case class TopPctLogic[K](heavyHittersPct: Double) extends HeavyHittersLogic[K] with Product with Serializable

    Finds all heavy hitters, i.

  325. class Tuple10Group[A, B, C, D, E, F, G, H, I, J] extends Tuple10Monoid[A, B, C, D, E, F, G, H, I, J] with Group[(A, B, C, D, E, F, G, H, I, J)]

    Combine 10 groups into a product group

  326. class Tuple10Monoid[A, B, C, D, E, F, G, H, I, J] extends Tuple10Semigroup[A, B, C, D, E, F, G, H, I, J] with Monoid[(A, B, C, D, E, F, G, H, I, J)]

    Combine 10 monoids into a product monoid

  327. class Tuple10Ring[A, B, C, D, E, F, G, H, I, J] extends Tuple10Group[A, B, C, D, E, F, G, H, I, J] with Ring[(A, B, C, D, E, F, G, H, I, J)]

    Combine 10 rings into a product ring

  328. class Tuple10Semigroup[A, B, C, D, E, F, G, H, I, J] extends Semigroup[(A, B, C, D, E, F, G, H, I, J)]

    Combine 10 semigroups into a product semigroup

  329. class Tuple11Group[A, B, C, D, E, F, G, H, I, J, K] extends Tuple11Monoid[A, B, C, D, E, F, G, H, I, J, K] with Group[(A, B, C, D, E, F, G, H, I, J, K)]

    Combine 11 groups into a product group

  330. class Tuple11Monoid[A, B, C, D, E, F, G, H, I, J, K] extends Tuple11Semigroup[A, B, C, D, E, F, G, H, I, J, K] with Monoid[(A, B, C, D, E, F, G, H, I, J, K)]

    Combine 11 monoids into a product monoid

  331. class Tuple11Ring[A, B, C, D, E, F, G, H, I, J, K] extends Tuple11Group[A, B, C, D, E, F, G, H, I, J, K] with Ring[(A, B, C, D, E, F, G, H, I, J, K)]

    Combine 11 rings into a product ring

  332. class Tuple11Semigroup[A, B, C, D, E, F, G, H, I, J, K] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K)]

    Combine 11 semigroups into a product semigroup

  333. class Tuple12Group[A, B, C, D, E, F, G, H, I, J, K, L] extends Tuple12Monoid[A, B, C, D, E, F, G, H, I, J, K, L] with Group[(A, B, C, D, E, F, G, H, I, J, K, L)]

    Combine 12 groups into a product group

  334. class Tuple12Monoid[A, B, C, D, E, F, G, H, I, J, K, L] extends Tuple12Semigroup[A, B, C, D, E, F, G, H, I, J, K, L] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L)]

    Combine 12 monoids into a product monoid

  335. class Tuple12Ring[A, B, C, D, E, F, G, H, I, J, K, L] extends Tuple12Group[A, B, C, D, E, F, G, H, I, J, K, L] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L)]

    Combine 12 rings into a product ring

  336. class Tuple12Semigroup[A, B, C, D, E, F, G, H, I, J, K, L] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L)]

    Combine 12 semigroups into a product semigroup

  337. class Tuple13Group[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Tuple13Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

    Combine 13 groups into a product group

  338. class Tuple13Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Tuple13Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

    Combine 13 monoids into a product monoid

  339. class Tuple13Ring[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Tuple13Group[A, B, C, D, E, F, G, H, I, J, K, L, M] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

    Combine 13 rings into a product ring

  340. class Tuple13Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

    Combine 13 semigroups into a product semigroup

  341. class Tuple14Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Tuple14Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

    Combine 14 groups into a product group

  342. class Tuple14Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Tuple14Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

    Combine 14 monoids into a product monoid

  343. class Tuple14Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Tuple14Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

    Combine 14 rings into a product ring

  344. class Tuple14Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

    Combine 14 semigroups into a product semigroup

  345. class Tuple15Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Tuple15Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

    Combine 15 groups into a product group

  346. class Tuple15Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Tuple15Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

    Combine 15 monoids into a product monoid

  347. class Tuple15Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Tuple15Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

    Combine 15 rings into a product ring

  348. class Tuple15Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

    Combine 15 semigroups into a product semigroup

  349. class Tuple16Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Tuple16Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

    Combine 16 groups into a product group

  350. class Tuple16Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Tuple16Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

    Combine 16 monoids into a product monoid

  351. class Tuple16Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Tuple16Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

    Combine 16 rings into a product ring

  352. class Tuple16Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

    Combine 16 semigroups into a product semigroup

  353. class Tuple17Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Tuple17Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

    Combine 17 groups into a product group

  354. class Tuple17Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Tuple17Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

    Combine 17 monoids into a product monoid

  355. class Tuple17Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Tuple17Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

    Combine 17 rings into a product ring

  356. class Tuple17Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

    Combine 17 semigroups into a product semigroup

  357. class Tuple18Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Tuple18Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

    Combine 18 groups into a product group

  358. class Tuple18Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Tuple18Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

    Combine 18 monoids into a product monoid

  359. class Tuple18Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Tuple18Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

    Combine 18 rings into a product ring

  360. class Tuple18Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

    Combine 18 semigroups into a product semigroup

  361. class Tuple19Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Tuple19Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Combine 19 groups into a product group

  362. class Tuple19Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Tuple19Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Combine 19 monoids into a product monoid

  363. class Tuple19Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Tuple19Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Combine 19 rings into a product ring

  364. class Tuple19Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Combine 19 semigroups into a product semigroup

  365. class Tuple20Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Tuple20Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

    Combine 20 groups into a product group

  366. class Tuple20Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Tuple20Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

    Combine 20 monoids into a product monoid

  367. class Tuple20Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Tuple20Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

    Combine 20 rings into a product ring

  368. class Tuple20Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

    Combine 20 semigroups into a product semigroup

  369. class Tuple21Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Tuple21Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

    Combine 21 groups into a product group

  370. class Tuple21Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Tuple21Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

    Combine 21 monoids into a product monoid

  371. class Tuple21Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Tuple21Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

    Combine 21 rings into a product ring

  372. class Tuple21Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

    Combine 21 semigroups into a product semigroup

  373. class Tuple22Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Tuple22Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] with Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

    Combine 22 groups into a product group

  374. class Tuple22Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Tuple22Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] with Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

    Combine 22 monoids into a product monoid

  375. class Tuple22Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Tuple22Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] with Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

    Combine 22 rings into a product ring

  376. class Tuple22Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

    Combine 22 semigroups into a product semigroup

  377. class Tuple2Group[A, B] extends Tuple2Monoid[A, B] with Group[(A, B)]

    Combine 2 groups into a product group

  378. class Tuple2Monoid[A, B] extends Tuple2Semigroup[A, B] with Monoid[(A, B)]

    Combine 2 monoids into a product monoid

  379. class Tuple2Ring[A, B] extends Tuple2Group[A, B] with Ring[(A, B)]

    Combine 2 rings into a product ring

  380. class Tuple2Semigroup[A, B] extends Semigroup[(A, B)]

    Combine 2 semigroups into a product semigroup

  381. class Tuple3Group[A, B, C] extends Tuple3Monoid[A, B, C] with Group[(A, B, C)]

    Combine 3 groups into a product group

  382. class Tuple3Monoid[A, B, C] extends Tuple3Semigroup[A, B, C] with Monoid[(A, B, C)]

    Combine 3 monoids into a product monoid

  383. class Tuple3Ring[A, B, C] extends Tuple3Group[A, B, C] with Ring[(A, B, C)]

    Combine 3 rings into a product ring

  384. class Tuple3Semigroup[A, B, C] extends Semigroup[(A, B, C)]

    Combine 3 semigroups into a product semigroup

  385. class Tuple4Group[A, B, C, D] extends Tuple4Monoid[A, B, C, D] with Group[(A, B, C, D)]

    Combine 4 groups into a product group

  386. class Tuple4Monoid[A, B, C, D] extends Tuple4Semigroup[A, B, C, D] with Monoid[(A, B, C, D)]

    Combine 4 monoids into a product monoid

  387. class Tuple4Ring[A, B, C, D] extends Tuple4Group[A, B, C, D] with Ring[(A, B, C, D)]

    Combine 4 rings into a product ring

  388. class Tuple4Semigroup[A, B, C, D] extends Semigroup[(A, B, C, D)]

    Combine 4 semigroups into a product semigroup

  389. class Tuple5Group[A, B, C, D, E] extends Tuple5Monoid[A, B, C, D, E] with Group[(A, B, C, D, E)]

    Combine 5 groups into a product group

  390. class Tuple5Monoid[A, B, C, D, E] extends Tuple5Semigroup[A, B, C, D, E] with Monoid[(A, B, C, D, E)]

    Combine 5 monoids into a product monoid

  391. class Tuple5Ring[A, B, C, D, E] extends Tuple5Group[A, B, C, D, E] with Ring[(A, B, C, D, E)]

    Combine 5 rings into a product ring

  392. class Tuple5Semigroup[A, B, C, D, E] extends Semigroup[(A, B, C, D, E)]

    Combine 5 semigroups into a product semigroup

  393. class Tuple6Group[A, B, C, D, E, F] extends Tuple6Monoid[A, B, C, D, E, F] with Group[(A, B, C, D, E, F)]

    Combine 6 groups into a product group

  394. class Tuple6Monoid[A, B, C, D, E, F] extends Tuple6Semigroup[A, B, C, D, E, F] with Monoid[(A, B, C, D, E, F)]

    Combine 6 monoids into a product monoid

  395. class Tuple6Ring[A, B, C, D, E, F] extends Tuple6Group[A, B, C, D, E, F] with Ring[(A, B, C, D, E, F)]

    Combine 6 rings into a product ring

  396. class Tuple6Semigroup[A, B, C, D, E, F] extends Semigroup[(A, B, C, D, E, F)]

    Combine 6 semigroups into a product semigroup

  397. class Tuple7Group[A, B, C, D, E, F, G] extends Tuple7Monoid[A, B, C, D, E, F, G] with Group[(A, B, C, D, E, F, G)]

    Combine 7 groups into a product group

  398. class Tuple7Monoid[A, B, C, D, E, F, G] extends Tuple7Semigroup[A, B, C, D, E, F, G] with Monoid[(A, B, C, D, E, F, G)]

    Combine 7 monoids into a product monoid

  399. class Tuple7Ring[A, B, C, D, E, F, G] extends Tuple7Group[A, B, C, D, E, F, G] with Ring[(A, B, C, D, E, F, G)]

    Combine 7 rings into a product ring

  400. class Tuple7Semigroup[A, B, C, D, E, F, G] extends Semigroup[(A, B, C, D, E, F, G)]

    Combine 7 semigroups into a product semigroup

  401. class Tuple8Group[A, B, C, D, E, F, G, H] extends Tuple8Monoid[A, B, C, D, E, F, G, H] with Group[(A, B, C, D, E, F, G, H)]

    Combine 8 groups into a product group

  402. class Tuple8Monoid[A, B, C, D, E, F, G, H] extends Tuple8Semigroup[A, B, C, D, E, F, G, H] with Monoid[(A, B, C, D, E, F, G, H)]

    Combine 8 monoids into a product monoid

  403. class Tuple8Ring[A, B, C, D, E, F, G, H] extends Tuple8Group[A, B, C, D, E, F, G, H] with Ring[(A, B, C, D, E, F, G, H)]

    Combine 8 rings into a product ring

  404. class Tuple8Semigroup[A, B, C, D, E, F, G, H] extends Semigroup[(A, B, C, D, E, F, G, H)]

    Combine 8 semigroups into a product semigroup

  405. class Tuple9Group[A, B, C, D, E, F, G, H, I] extends Tuple9Monoid[A, B, C, D, E, F, G, H, I] with Group[(A, B, C, D, E, F, G, H, I)]

    Combine 9 groups into a product group

  406. class Tuple9Monoid[A, B, C, D, E, F, G, H, I] extends Tuple9Semigroup[A, B, C, D, E, F, G, H, I] with Monoid[(A, B, C, D, E, F, G, H, I)]

    Combine 9 monoids into a product monoid

  407. class Tuple9Ring[A, B, C, D, E, F, G, H, I] extends Tuple9Group[A, B, C, D, E, F, G, H, I] with Ring[(A, B, C, D, E, F, G, H, I)]

    Combine 9 rings into a product ring

  408. class Tuple9Semigroup[A, B, C, D, E, F, G, H, I] extends Semigroup[(A, B, C, D, E, F, G, H, I)]

    Combine 9 semigroups into a product semigroup

  409. case class Universe[T]() extends Interval[T] with Product with Serializable

  410. class UnsafeFromAlgebraRig[T] extends Ring[T]

    In some legacy cases, we have implemented Rings where we lacked the full laws.

  411. class UnsafeFromAlgebraRng[T] extends Ring[T]

    In some legacy cases, we have implemented Rings where we lacked the full laws.

  412. sealed trait Upper[T] extends Interval[T]

  413. trait VectorSpace[F, C[_]] extends Serializable

    Annotations
    @implicitNotFound( ... )
  414. case class BitSetLite(in: Array[Byte]) extends Product with Serializable

    A super lightweight (hopefully) version of BitSet

Value Members

  1. object AdaptiveVector

    Some functions to create or convert AdaptiveVectors

  2. object AdjoinedUnit extends Serializable

  3. object AffineFunction extends Serializable

  4. object Aggregator extends Serializable

    Aggregators compose well.

  5. object AndVal extends Serializable

  6. object AndValMonoid extends Monoid[AndVal]

    Boolean AND monoid.

  7. object Applicative

    Follows the type-class pattern for the Applicative trait

  8. object Approximate extends Serializable

  9. object ApproximateBoolean extends Serializable

  10. object ArrayBufferedOperation extends Serializable

  11. object AveragedGroup extends Group[AveragedValue] with CommutativeGroup[AveragedValue]

    Group implementation for AveragedValue.

  12. object AveragedValue extends Serializable

    Provides a set of operations needed to create and use AveragedValue instances.

  13. object Averager extends MonoidAggregator[Double, AveragedValue, Double]

    Aggregator that uses AveragedValue to calculate the mean of all Double values in the stream.

  14. object BF extends Serializable

  15. object BFInstance extends Serializable

  16. object Batched extends Serializable

  17. object BigDecimalRing extends NumericRing[BigDecimal]

  18. object BigIntRing extends NumericRing[BigInt]

  19. object BloomFilter

  20. object BloomFilterAggregator extends Serializable

  21. object BooleanRing extends Ring[Boolean]

  22. object Bytes extends Serializable

  23. object CMS extends Serializable

  24. object CMSFunctions

    Helper functions to generate or to translate between various CMS parameters (cf.

  25. object CMSHasher extends Serializable

  26. object CMSHasherImplicits

    This formerly held the instances that moved to object CMSHasher

  27. object CMSInstance extends Serializable

  28. object DecayedValue extends Serializable

  29. object DecayedVector extends Serializable

    Represents a container class together with time.

  30. object DoubleRing extends Ring[Double]

  31. object ExpHist extends Serializable

  32. val Field: algebra.ring.Field.type

  33. object First extends FirstInstances with Serializable

    Provides a set of operations and typeclass instances needed to use First instances.

  34. object FlatMapPreparer extends Serializable

  35. object FloatRing extends Ring[Float]

  36. object Fold extends Serializable

    Methods to create and run Folds.

  37. object Functor

    Follows the type-class pattern for the Functor trait

  38. object GeneratedTupleAggregator extends GeneratedTupleAggregator

  39. object Group extends GeneratedGroupImplicits with ProductGroups with FromAlgebraGroupImplicit0 with Serializable

  40. object Hash128 extends Serializable

    This gives default hashes using Murmur128 with a seed of 12345678 (for no good reason, but it should not be changed lest we break serialized HLLs)

  41. object HeavyHitters extends Serializable

  42. object HyperLogLog

    Implementation of the HyperLogLog approximate counting as a Monoid

  43. object HyperLogLogAggregator extends Serializable

    This object makes it easier to create Aggregator instances that use HLL

  44. object Identity extends Serializable

  45. object IdentityMonad extends Monad[Identity]

  46. object IntRing extends Ring[Int]

  47. object IntegralPredecessible extends Serializable

  48. object IntegralSuccessible extends Serializable

  49. object Interval extends Serializable

  50. object JBoolRing extends Ring[Boolean]

  51. object JDoubleRing extends Ring[Double]

  52. object JFloatRing extends Ring[Float]

  53. object JIntRing extends Ring[Integer]

  54. object JLongRing extends Ring[Long]

  55. object JShortRing extends Ring[Short]

  56. object Last extends LastInstances with Serializable

    Provides a set of operations and typeclass instances needed to use Last instances.

  57. object LongRing extends Ring[Long]

  58. object MapAggregator extends Serializable

  59. object MapAlgebra

  60. object MapPreparer extends Serializable

  61. object Max extends MaxInstances with Serializable

    Provides a set of operations and typeclass instances needed to use Max instances.

  62. object Metric extends Serializable

    A Metric[V] m is a function (V, V) => Double that satisfies the following properties:

  63. object Min extends MinInstances with Serializable

    Provides a set of operations and typeclass instances needed to use Min instances.

  64. object MinHasher extends Serializable

  65. object MinPlus extends Serializable

  66. object MinPlusZero extends MinPlus[Nothing] with Product with Serializable

  67. object Moments extends Serializable

  68. object MomentsAggregator extends MonoidAggregator[Double, Moments, Moments]

  69. object MomentsGroup extends Group[Moments] with CommutativeGroup[Moments]

    A monoid to perform moment calculations.

  70. object Monad

    Follows the type-class pattern for the Monad trait

  71. object Monoid extends GeneratedMonoidImplicits with ProductMonoids with FromAlgebraMonoidImplicit0 with Serializable

  72. object MultiAggregator

  73. object NullGroup extends ConstantGroup[Null]

  74. object Operators

  75. object OrVal extends Serializable

  76. object OrValMonoid extends Monoid[OrVal]

    Boolean OR monoid.

  77. object Predecessible extends Serializable

  78. object Preparer extends Serializable

  79. object Priority extends FindPreferred

  80. object QTree extends Serializable

    A QTree provides an approximate Map[Double,A:Monoid] suitable for range queries, quantile queries, and combinations of these (for example, if you use a numeric A, you can derive the inter-quartile mean).

  81. object QTreeAggregator extends Serializable

  82. object ResetState

  83. object RichCBitSet

  84. object RightFolded

    This is an associative, but not commutative monoid Also, you must start on the right, with a value, and all subsequent RightFolded must be RightFoldedToFold objects or zero

  85. object RightFolded2

    This monoid takes a list of values of type In or Out, and folds to the right all the Ins into Out values, leaving you with a list of Out values, then finally, maps those outs onto Acc, where there is a group, and adds all the Accs up.

  86. object RightFoldedZero extends RightFolded[Nothing, Nothing] with Product with Serializable

  87. object RightFoldedZero2 extends RightFolded2[Nothing, Nothing, Nothing] with Product with Serializable

  88. object Ring extends GeneratedRingImplicits with ProductRings with RingImplicits0 with Serializable

  89. object SGD

  90. object SGDPos extends Serializable

  91. object SGDWeights extends Serializable

  92. object SGDZero extends SGD[Nothing] with Product with Serializable

  93. object SSMany extends Serializable

  94. object ScopedTopNCMS

  95. object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups with FromAlgebraSemigroupImplicit0 with Serializable

  96. object SetDiff extends Serializable

  97. object ShortRing extends Ring[Short]

  98. object SketchMap extends Serializable

    Data structure representing an approximation of Map[K, V], where V has an implicit ordering and monoid.

  99. object SketchMapParams extends Serializable

  100. object SpaceSaver

  101. object SparseCMS extends Serializable

  102. object StringMonoid extends Monoid[String]

  103. object Successible extends Serializable

  104. object SummingCache extends Serializable

  105. object SummingIterator extends Serializable

    Creates an Iterator that emits partial sums of an input Iterator[V].

  106. object SummingQueue extends Serializable

  107. object SummingWithHitsCache extends Serializable

  108. object TopCMSInstance extends Serializable

  109. object TopKMonoid extends Serializable

  110. object TopNCMS

  111. object TopPctCMS

  112. object UnitGroup extends ConstantGroup[Unit]

  113. object VectorSpace extends Serializable

    This class represents a vector space.

  114. object field

    This is here to ease transition to using algebra.

  115. package macros

  116. package matrix

  117. package monad

  118. package mutable

  119. package statistics

Inherited from AnyRef

Inherited from Any

Ungrouped