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. class ConstantRing[T] extends ConstantGroup[T] with Ring[T]

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

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

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

  63. 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

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

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

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

    Either semigroup is useful for error handling.

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

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

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

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

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

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

  73. 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.

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

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

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

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

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

    To keep code using algebird.

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

  78. 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.

  79. 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.

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

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

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

    Folds are first-class representations of "Traversable.

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

    Folds are Applicatives!

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

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

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

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

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

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

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

    Function1 monoid.

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

    Simple implementation of a Functor type-class.

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

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

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

  92. trait GeneratedGroupImplicits extends AnyRef

  93. trait GeneratedMonoidImplicits extends AnyRef

  94. trait GeneratedRingImplicits extends AnyRef

  95. trait GeneratedSemigroupImplicits extends AnyRef

  96. trait GeneratedTupleAggregator extends AnyRef

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

  98. 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

  99. 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).

  100. sealed abstract class HLL extends Serializable

  101. 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.

  102. trait Hash128[-K] extends Serializable

    A typeclass to represent hashing to 128 bits.

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

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

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

    Containers for holding heavy hitter items and their associated counts.

  106. abstract class HeavyHittersLogic[K] extends Serializable

    Controls how a CMS that implements CMSHeavyHitters tracks heavy hitters.

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

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

  109. class HyperLogLogSeriesMonoid extends Monoid[HLLSeries]

    val hllSeriesMonoid = new HyperLogLogSeriesMonoid(bits)

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

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

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

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

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

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

  116. 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]]

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

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

  119. 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

  120. sealed trait Interval[T] extends Serializable

    Represents a single interval on a T with an Ordering

  121. class InvariantGroup[T, U] extends InvariantMonoid[T, U] with Group[U]

  122. class InvariantMonoid[T, U] extends InvariantSemigroup[T, U] with Monoid[U]

  123. class InvariantRing[T, U] extends InvariantGroup[T, U] with Ring[U]

  124. class InvariantSemigroup[T, U] extends Semigroup[U]

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

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

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

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

  127. 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.

  128. 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.

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

    List concatenation monoid.

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

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

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

    You can think of this as a Sparse vector group

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

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

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

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

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

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

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

    Tracks the maximum wrapped instance of some ordered type T.

  139. 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.

  140. trait Metric[-V] extends Serializable

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

    Tracks the minimum wrapped instance of some ordered type T.

  142. 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.

  143. 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].

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

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

  145. class MinHasher16 extends MinHasher[Char]

  146. class MinHasher32 extends MinHasher[Int]

  147. sealed trait MinPlus[+V] extends Serializable

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

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

  150. class MinusOp[T] extends AnyRef

  151. 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.

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

    Simple implementation of a Monad type-class.

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

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

  154. 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

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

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

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

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

  159. trait NumericRingProvider extends AnyRef

  160. 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

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

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

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

  163. class PlusOp[T] extends AnyRef

  164. trait Predecessible[T] extends Serializable

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

  165. 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.

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

    Priority is a type class for prioritized implicit search.

  167. 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

  168. 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

  169. 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

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

    Combine 10 semigroups into a product semigroup

  171. 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

  172. 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

  173. 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

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

    Combine 11 semigroups into a product semigroup

  175. 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

  176. 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

  177. 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

  178. 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

  179. 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

  180. 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

  181. 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

  182. 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

  183. 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

  184. 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

  185. 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

  186. 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

  187. 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

  188. 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

  189. 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

  190. 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

  191. 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

  192. 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

  193. 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

  194. 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

  195. 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

  196. 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

  197. 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

  198. 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

  199. 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

  200. 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

  201. 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

  202. 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

  203. 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

  204. 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

  205. 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

  206. 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

  207. 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

  208. 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

  209. 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

  210. 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

  211. 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

  212. 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

  213. 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

  214. 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

  215. 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

  216. 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

  217. 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

  218. 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

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

    Combine 2 groups into a product group

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

    Combine 2 monoids into a product monoid

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

    Combine 2 rings into a product ring

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

    Combine 2 semigroups into a product semigroup

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

    Combine 3 groups into a product group

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

    Combine 3 monoids into a product monoid

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

    Combine 3 rings into a product ring

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

    Combine 3 semigroups into a product semigroup

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

    Combine 4 groups into a product group

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

    Combine 4 monoids into a product monoid

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

    Combine 4 rings into a product ring

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

    Combine 4 semigroups into a product semigroup

  231. 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

  232. 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

  233. 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

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

    Combine 5 semigroups into a product semigroup

  235. 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

  236. 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

  237. 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

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

    Combine 6 semigroups into a product semigroup

  239. 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

  240. 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

  241. 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

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

    Combine 7 semigroups into a product semigroup

  243. 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

  244. 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

  245. 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

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

    Combine 8 semigroups into a product semigroup

  247. 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

  248. 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

  249. 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

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

    Combine 9 semigroups into a product semigroup

  251. trait ProductGroups extends AnyRef

  252. trait ProductMonoids extends AnyRef

  253. trait ProductRings extends AnyRef

  254. trait ProductSemigroups extends AnyRef

  255. final class PureOp[A] extends AnyVal

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

  257. 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.

  258. trait QTreeAggregatorLike[T] extends AnyRef

  259. 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.

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

  261. 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

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

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

  264. final class RichCBitSet extends AnyVal

  265. class RichTraversable[T] extends AnyRef

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

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

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

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

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

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

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

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

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

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

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

  276. 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.

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

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

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

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

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

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

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

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

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

    K1 defines a scope for the CMS.

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

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

  287. 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.

  288. 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.

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

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

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

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

    Set union monoid.

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

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

    convert is not not implemented here

  294. 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.

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

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

  297. 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.

  298. 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.

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

    Responsible for creating instances of SketchMap.

  300. 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.

  301. 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.

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

  303. 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.

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

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

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

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

  307. trait Successible[T] extends Serializable

    This is a typeclass to represent things which increase.

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

    Sum the entire iterator one item at a time.

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

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

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

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

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

    A SummingCache that also tracks the number of key hits

  313. class TimesOp[T] extends AnyRef

  314. 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.

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

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

  317. 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.

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

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

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

    Zero element.

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

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

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

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

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

    An Aggregator for TopNCMS.

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

    Monoid for top-N based TopCMS sketches.

  326. 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.

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

    An Aggregator for TopPctCMS.

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

    Monoid for Top-% based TopCMS sketches.

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

    Finds all heavy hitters, i.

  330. 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

  331. 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

  332. 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

  333. 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

  334. 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

  335. 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

  336. 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

  337. 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

  338. 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

  339. 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

  340. 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

  341. 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

  342. 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

  343. 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

  344. 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

  345. 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

  346. 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

  347. 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

  348. 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

  349. 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

  350. 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

  351. 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

  352. 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

  353. 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

  354. 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

  355. 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

  356. 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

  357. 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

  358. 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

  359. 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

  360. 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

  361. 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

  362. 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

  363. 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

  364. 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

  365. 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

  366. 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

  367. 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

  368. 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

  369. 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

  370. 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

  371. 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

  372. 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

  373. 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

  374. 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

  375. 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

  376. 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

  377. 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

  378. 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

  379. 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

  380. 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

  381. 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

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

    Combine 2 groups into a product group

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

    Combine 2 monoids into a product monoid

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

    Combine 2 rings into a product ring

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

    Combine 2 semigroups into a product semigroup

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

    Combine 3 groups into a product group

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

    Combine 3 monoids into a product monoid

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

    Combine 3 rings into a product ring

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

    Combine 3 semigroups into a product semigroup

  390. 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

  391. 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

  392. 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

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

    Combine 4 semigroups into a product semigroup

  394. 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

  395. 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

  396. 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

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

    Combine 5 semigroups into a product semigroup

  398. 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

  399. 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

  400. 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

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

    Combine 6 semigroups into a product semigroup

  402. 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

  403. 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

  404. 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

  405. 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

  406. 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

  407. 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

  408. 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

  409. 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

  410. 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

  411. 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

  412. 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

  413. 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

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

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

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

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

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

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

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

    Annotations
    @implicitNotFound( ... )
  419. case class Window[T](total: T, items: Queue[T]) extends Product with Serializable

    Convenience case class defined with a monoid for aggregating elements over a finite window.

  420. abstract class WindowMonoid[T] extends Monoid[Window[T]]

    Provides a natural monoid for combining windows truncated to some window size.

  421. final case class WindowMonoidFromGroup[T](windowSize: Int)(implicit group: Group[T]) extends WindowMonoid[T] with Product with Serializable

  422. final case class WindowMonoidFromMonoid[T](windowSize: Int)(implicit m: Monoid[T]) extends WindowMonoid[T] with Product with Serializable

  423. 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 Window extends Serializable

  115. object field

    This is here to ease transition to using algebra.

  116. package macros

  117. package matrix

  118. package monad

  119. package mutable

  120. package statistics

Inherited from AnyRef

Inherited from Any

Ungrouped