com.twitter

algebird

package algebird

Visibility
  1. Public
  2. All

Type Members

  1. abstract class AbstractField[T] extends Field[T]

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

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

    For use from Java/minimizing code bloat in scala

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

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

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

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

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

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

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

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

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

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

  13. case class AndVal(get: Boolean) extends Product with Serializable

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

  15. case class ApproximateBoolean(isTrue: Boolean, withProb: Double) extends Product with Serializable

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

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

  18. sealed abstract class BF extends Serializable

    Bloom Filter data structure

  19. case class BFHash(numHashes: Int, width: Int, seed: Long) extends (String) ⇒ Iterable[Int] with Product with Serializable

  20. case class BFInstance(hashes: BFHash, bits: BitSet, width: Int) extends BF with Product with Serializable

  21. case class BFItem(item: String, hashes: BFHash, width: Int) extends BF with Product with Serializable

    Bloom Filter with 1 value.

  22. case class BFSparse(hashes: BFHash, bits: EWAHCompressedBitmap, width: Int) extends BF with Product with Serializable

  23. case class BFZero(hashes: BFHash, width: Int) extends BF with Product with Serializable

    Empty bloom filter.

  24. case class BitSetLite(in: Array[Byte]) extends Product with Serializable

    A super lightweight (hopefully) version of BitSet

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

  26. case class BloomFilterMonoid(numHashes: Int, width: Int, seed: Int) extends Monoid[BF] with Product with Serializable

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

  27. trait Buffered[I, O] extends Serializable

    Represents something that consumes I and may emit O.

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

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

  30. sealed abstract class CMS extends Serializable

    The actual Count-Min sketch data structure.

  31. case class CMSCountsTable(counts: Vector[Vector[Long]]) extends Product with Serializable

    The 2-dimensional table of counters used in the Count-Min sketch.

  32. case class CMSHash(a: Int, b: Int, width: Int) extends Product with Serializable

    The Count-Min sketch uses pairwise independent hash functions drawn from a universal hashing family of the form

  33. case class CMSInstance(countsTable: CMSCountsTable, totalCount: Long, hhs: HeavyHitters, params: CMSParams) extends CMS with Product with Serializable

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

  34. case class CMSItem(item: Long, params: CMSParams) extends CMS with Product with Serializable

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

  35. case class CMSParams(hashes: Seq[CMSHash], eps: Double, delta: Double, heavyHittersPct: Double) extends Product with Serializable

    Convenience class for holding constant parameters of a Count-Min sketch.

  36. case class CMSZero(params: CMSParams) extends CMS with Product with Serializable

    Used for initialization.

  37. class CassandraMurmurHash extends AnyRef

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

  39. case class CountMinSketchAggregator(cmsMonoid: CountMinSketchMonoid) extends MonoidAggregator[Long, CMS, CMS] with Product with Serializable

    An Aggregator for the CountMinSketch.

  40. class CountMinSketchMonoid extends Monoid[CMS]

    Monoid for adding Count-Min sketches.

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

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

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

  44. case class DenseHLL(bits: Int, v: IndexedSeq[Byte]) extends HLL with Product with Serializable

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

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

  46. class DivOp[T] extends AnyRef

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

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

    Either semigroup is useful for error handling.

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

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

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

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

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

  54. case class ExclusiveLower[T](lower: T, ordering: Ordering[T]) extends Interval[T] with Lower[T] with Product with Serializable

  55. case class ExclusiveUpper[T](upper: T, ordering: Ordering[T]) extends Interval[T] with Upper[T] with Product with Serializable

  56. trait Field[T] extends Ring[T]

    Field: Ring + division.

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

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

    Folds are first-class representations of "Traversable.

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

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

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

    Function1 monoid.

  61. trait GeneratedGroupImplicits extends AnyRef

  62. trait GeneratedMonoidImplicits extends AnyRef

  63. trait GeneratedRingImplicits extends AnyRef

  64. trait GeneratedSemigroupImplicits extends AnyRef

  65. trait GeneratedTupleAggregator extends AnyRef

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

  67. trait GenericMapRing[K, V, M <: Map[K, V]] extends Ring[M] with MapOperations[K, V, M]

    You can think of this as a Sparse vector ring

  68. trait Group[T] extends Monoid[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).

  69. sealed abstract class HLL extends Serializable

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

  71. case class HeavyHitter(item: Long, count: Long) extends Product with Serializable

  72. case class HeavyHitters(hhs: SortedSet[HeavyHitter]) extends Product with Serializable

    Containers for holding heavy hitter items and their associated counts.

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

  74. class HyperLogLogMonoid extends Monoid[HLL]

  75. case class InclusiveLower[T](lower: T, ordering: Ordering[T]) extends Interval[T] with Lower[T] with Product with Serializable

  76. case class InclusiveUpper[T](upper: T, ordering: Ordering[T]) extends Interval[T] with Upper[T] with Product with Serializable

  77. class IndexedSeqArrayByte extends IndexedSeq[Byte]

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

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

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

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

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

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

  84. sealed trait Interval[T] extends Serializable

    Represents a single interval on a T with an Ordering

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

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

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

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

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

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

    List concatenation monoid.

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

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

    You can think of this as a Sparse vector group

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

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

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

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

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

  96. trait Metric[-V] extends Serializable

    Annotations
    @implicitNotFound( ... )

  97. case class Min[+T](get: T) extends Product with Serializable

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

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

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

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

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

  101. class MinHasher16 extends MinHasher[Char]

  102. class MinHasher32 extends MinHasher[Int]

  103. sealed abstract class MinPlus[+V] extends Serializable

  104. class MinPlusSemiring[V] extends Ring[MinPlus[V]]

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

  106. class MinusOp[T] extends AnyRef

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

  108. trait Monad[M[_]] extends AnyRef

    Simple implementation of a Monad type-class

  109. class MonadField[T, M[_]] extends MonadRing[T, M] with Field[M[T]]

  110. class MonadGroup[T, M[_]] extends MonadMonoid[T, M] with Group[M[T]]

  111. class MonadMonoid[T, M[_]] extends MonadSemigroup[T, M] with Monoid[M[T]]

  112. class MonadOperators[A, M[A]] extends AnyRef

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

  113. class MonadRing[T, M[_]] extends MonadGroup[T, M] with Ring[M[T]]

  114. class MonadSemigroup[T, M[_]] extends Semigroup[M[T]]

  115. trait Monoid[T] extends Semigroup[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

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

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

  118. case class MurmurHash128(seed: Long) extends Product with Serializable

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

  120. class NumericSuccessible[T] extends Successible[T]

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

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

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

  123. case class OrVal(get: Boolean) extends Product with Serializable

  124. class PlusOp[T] extends AnyRef

  125. trait Predecessible[T] extends Serializable

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

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

    Combine 10 groups into a product group

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

    Combine 10 monoids into a product monoid

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

    Combine 10 rings into a product ring

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

    Combine 10 semigroups into a product semigroup

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

    Combine 11 groups into a product group

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

    Combine 11 monoids into a product monoid

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

    Combine 11 rings into a product ring

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

    Combine 11 semigroups into a product semigroup

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

    Combine 12 groups into a product group

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

    Combine 12 monoids into a product monoid

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

    Combine 12 rings into a product ring

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

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

    Combine 13 groups into a product group

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

    Combine 13 monoids into a product monoid

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

    Combine 13 rings into a product ring

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

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

    Combine 14 groups into a product group

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

    Combine 14 monoids into a product monoid

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

    Combine 14 rings into a product ring

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

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

    Combine 15 groups into a product group

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

    Combine 15 monoids into a product monoid

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

    Combine 15 rings into a product ring

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

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

    Combine 16 groups into a product group

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

    Combine 16 monoids into a product monoid

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

    Combine 16 rings into a product ring

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

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

    Combine 17 groups into a product group

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

    Combine 17 monoids into a product monoid

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

    Combine 17 rings into a product ring

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

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

    Combine 18 groups into a product group

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

    Combine 18 monoids into a product monoid

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

    Combine 18 rings into a product ring

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

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

    Combine 19 groups into a product group

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

    Combine 19 monoids into a product monoid

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

    Combine 19 rings into a product ring

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

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

    Combine 20 groups into a product group

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

    Combine 20 monoids into a product monoid

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

    Combine 20 rings into a product ring

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

  170. 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 Group[X]

    Combine 21 groups into a product group

  171. 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 Monoid[X]

    Combine 21 monoids into a product monoid

  172. 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 Ring[X]

    Combine 21 rings into a product ring

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

  174. 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 Group[X]

    Combine 22 groups into a product group

  175. 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 Monoid[X]

    Combine 22 monoids into a product monoid

  176. 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 Ring[X]

    Combine 22 rings into a product ring

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

  178. class Product2Group[X, A, B] extends Group[X]

    Combine 2 groups into a product group

  179. class Product2Monoid[X, A, B] extends Monoid[X]

    Combine 2 monoids into a product monoid

  180. class Product2Ring[X, A, B] extends Ring[X]

    Combine 2 rings into a product ring

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

    Combine 2 semigroups into a product semigroup

  182. class Product3Group[X, A, B, C] extends Group[X]

    Combine 3 groups into a product group

  183. class Product3Monoid[X, A, B, C] extends Monoid[X]

    Combine 3 monoids into a product monoid

  184. class Product3Ring[X, A, B, C] extends Ring[X]

    Combine 3 rings into a product ring

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

    Combine 3 semigroups into a product semigroup

  186. class Product4Group[X, A, B, C, D] extends Group[X]

    Combine 4 groups into a product group

  187. class Product4Monoid[X, A, B, C, D] extends Monoid[X]

    Combine 4 monoids into a product monoid

  188. class Product4Ring[X, A, B, C, D] extends Ring[X]

    Combine 4 rings into a product ring

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

    Combine 4 semigroups into a product semigroup

  190. class Product5Group[X, A, B, C, D, E] extends Group[X]

    Combine 5 groups into a product group

  191. class Product5Monoid[X, A, B, C, D, E] extends Monoid[X]

    Combine 5 monoids into a product monoid

  192. class Product5Ring[X, A, B, C, D, E] extends Ring[X]

    Combine 5 rings into a product ring

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

    Combine 5 semigroups into a product semigroup

  194. class Product6Group[X, A, B, C, D, E, F] extends Group[X]

    Combine 6 groups into a product group

  195. class Product6Monoid[X, A, B, C, D, E, F] extends Monoid[X]

    Combine 6 monoids into a product monoid

  196. class Product6Ring[X, A, B, C, D, E, F] extends Ring[X]

    Combine 6 rings into a product ring

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

    Combine 6 semigroups into a product semigroup

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

    Combine 7 groups into a product group

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

    Combine 7 monoids into a product monoid

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

    Combine 7 rings into a product ring

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

    Combine 7 semigroups into a product semigroup

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

    Combine 8 groups into a product group

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

    Combine 8 monoids into a product monoid

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

    Combine 8 rings into a product ring

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

    Combine 8 semigroups into a product semigroup

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

    Combine 9 groups into a product group

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

    Combine 9 monoids into a product monoid

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

    Combine 9 rings into a product ring

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

    Combine 9 semigroups into a product semigroup

  210. trait ProductGroups extends AnyRef

  211. trait ProductMonoids extends AnyRef

  212. trait ProductRings extends AnyRef

  213. trait ProductSemigroups extends AnyRef

  214. class PureOp[A] extends AnyRef

  215. case class QTree[A](offset: Long, level: Int, count: Long, sum: A, lowerChild: Option[QTree[A]], upperChild: Option[QTree[A]], monoid: Monoid[A]) extends Product with Serializable

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

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

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

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

  220. class RichCBitSet extends AnyRef

  221. class RichTraversable[T] extends AnyRef

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

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

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

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

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

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

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

  229. trait Ring[T] extends Group[T]

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

  230. trait RingAggregator[-A, B, +C] extends Aggregator[A, B, C]

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

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

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

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

  235. case class SSMany[T](capacity: Int, counters: Map[T, (Long, Long)], buckets: SortedMap[Long, Set[T]]) extends SpaceSaver[T] with Product with Serializable

  236. case class SSOne[T](capacity: Int, item: T) extends SpaceSaver[T] with Product with Serializable

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

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

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

  240. trait Semigroup[T] extends Serializable

    Semigroup: This is a class with a plus method that is associative: a+(b+c) = (a+b)+c

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

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

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

    Set union monoid.

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

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

  246. case class SketchMapAggregator[K, V](params: SketchMapParams[K], skmMonoid: SketchMapMonoid[K, V], 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.

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

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

  248. class SketchMapMonoid[K, V] extends Monoid[SketchMap[K, V]]

    Responsible for creating instances of SketchMap.

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

    Convenience class for holding constant parameters of a Sketch Map.

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

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

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

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

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

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

  255. trait Successible[T] extends AnyRef

    This is a monoid to represent things which increase.

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

    Sum the entire iterator one item at a time.

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

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

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

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

  260. class TimesOp[T] extends AnyRef

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

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

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

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

    Combine 10 groups into a product group

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

    Combine 10 monoids into a product monoid

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

    Combine 10 rings into a product ring

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

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

    Combine 11 groups into a product group

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

    Combine 11 monoids into a product monoid

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

    Combine 11 rings into a product ring

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

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

    Combine 12 groups into a product group

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

    Combine 12 monoids into a product monoid

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

    Combine 12 rings into a product ring

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

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

    Combine 13 groups into a product group

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

    Combine 13 monoids into a product monoid

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

    Combine 13 rings into a product ring

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

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

    Combine 14 groups into a product group

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

    Combine 14 monoids into a product monoid

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

    Combine 14 rings into a product ring

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

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

    Combine 15 groups into a product group

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

    Combine 15 monoids into a product monoid

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

    Combine 15 rings into a product ring

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

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

    Combine 16 groups into a product group

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

    Combine 16 monoids into a product monoid

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

    Combine 16 rings into a product ring

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

  291. class Tuple17Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends 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

  292. class Tuple17Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends 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

  293. class Tuple17Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends 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

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

  295. class Tuple18Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends 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

  296. class Tuple18Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends 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

  297. class Tuple18Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends 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

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

  299. class Tuple19Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends 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

  300. class Tuple19Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends 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

  301. class Tuple19Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends 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

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

  303. class Tuple20Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends 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

  304. class Tuple20Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends 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

  305. class Tuple20Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends 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

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

  307. class Tuple21Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends 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

  308. class Tuple21Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends 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

  309. class Tuple21Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends 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

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

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

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

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

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

  315. class Tuple2Group[A, B] extends Group[(A, B)]

    Combine 2 groups into a product group

  316. class Tuple2Monoid[A, B] extends Monoid[(A, B)]

    Combine 2 monoids into a product monoid

  317. class Tuple2Ring[A, B] extends Ring[(A, B)]

    Combine 2 rings into a product ring

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

    Combine 2 semigroups into a product semigroup

  319. class Tuple3Group[A, B, C] extends Group[(A, B, C)]

    Combine 3 groups into a product group

  320. class Tuple3Monoid[A, B, C] extends Monoid[(A, B, C)]

    Combine 3 monoids into a product monoid

  321. class Tuple3Ring[A, B, C] extends Ring[(A, B, C)]

    Combine 3 rings into a product ring

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

    Combine 3 semigroups into a product semigroup

  323. class Tuple4Group[A, B, C, D] extends Group[(A, B, C, D)]

    Combine 4 groups into a product group

  324. class Tuple4Monoid[A, B, C, D] extends Monoid[(A, B, C, D)]

    Combine 4 monoids into a product monoid

  325. class Tuple4Ring[A, B, C, D] extends Ring[(A, B, C, D)]

    Combine 4 rings into a product ring

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

    Combine 4 semigroups into a product semigroup

  327. class Tuple5Group[A, B, C, D, E] extends Group[(A, B, C, D, E)]

    Combine 5 groups into a product group

  328. class Tuple5Monoid[A, B, C, D, E] extends Monoid[(A, B, C, D, E)]

    Combine 5 monoids into a product monoid

  329. class Tuple5Ring[A, B, C, D, E] extends Ring[(A, B, C, D, E)]

    Combine 5 rings into a product ring

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

    Combine 5 semigroups into a product semigroup

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

    Combine 6 groups into a product group

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

    Combine 6 monoids into a product monoid

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

    Combine 6 rings into a product ring

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

    Combine 6 semigroups into a product semigroup

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

    Combine 7 groups into a product group

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

    Combine 7 monoids into a product monoid

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

    Combine 7 rings into a product ring

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

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

    Combine 8 groups into a product group

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

    Combine 8 monoids into a product monoid

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

    Combine 8 rings into a product ring

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

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

    Combine 9 groups into a product group

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

    Combine 9 monoids into a product monoid

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

    Combine 9 rings into a product ring

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

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

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

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

    Annotations
    @implicitNotFound( ... )

  350. class SortedTakeListMonoid[T] extends Monoid[List[T]]

    A sorted-take List monoid (not the default, you can set: implicit val sortmon = new SortedTakeListMonoid[T](10) to use this instead of the standard list This returns the k least values: equivalent to: (left ++ right).

Value Members

  1. object AdaptiveVector extends AnyRef

    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 Approximate extends Serializable

  8. object ApproximateBoolean extends Serializable

  9. object AveragedGroup extends Group[AveragedValue]

  10. object AveragedValue extends Serializable

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

  12. object BFInstance extends Serializable

  13. object BigIntRing extends NumericRing[BigInt]

  14. object BloomFilter extends AnyRef

  15. object BloomFilterAggregator extends Serializable

  16. object BooleanField extends Field[Boolean]

  17. object CMS extends Serializable

  18. object CMSCountsTable extends Serializable

  19. object CMSInstance extends Serializable

  20. object CassandraMurmurHash extends

  21. object DecayedValue extends Serializable

  22. object DecayedVector extends Serializable

    Represents a container class together with time.

  23. object DoubleField extends Field[Double]

  24. object Field extends Serializable

  25. object First extends Serializable

  26. object FloatField extends Field[Float]

  27. object Fold extends Serializable

    Methods to create and run Folds.

  28. object GeneratedTupleAggregator extends GeneratedTupleAggregator

  29. object Group extends GeneratedGroupImplicits with ProductGroups with Serializable

  30. object HeavyHitter extends Serializable

  31. object HyperLogLog extends AnyRef

    Implementation of the HyperLogLog approximate counting as a Monoid

  32. object HyperLogLogAggregator extends Serializable

  33. object IntRing extends Ring[Int]

  34. object Interval extends Serializable

  35. object JBoolField extends Field[Boolean]

  36. object JDoubleField extends Field[Double]

  37. object JFloatField extends Field[Float]

  38. object JIntRing extends Ring[Integer]

  39. object JLongRing extends Ring[Long]

  40. object JShortRing extends Ring[Short]

  41. object Last extends Serializable

  42. object LongRing extends Ring[Long]

  43. object MapAlgebra extends AnyRef

  44. object Max extends Serializable

  45. object Metric extends Serializable

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

  46. object Min extends Serializable

  47. object MinHasher extends Serializable

  48. object MinPlus extends Serializable

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

  50. object Moments extends Serializable

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

  52. object MomentsGroup extends Group[Moments]

    A monoid to perform moment calculations.

  53. object Monad extends AnyRef

    Follows the type-class pattern for the Monad trait

  54. object Monoid extends GeneratedMonoidImplicits with ProductMonoids with Serializable

  55. object NullGroup extends ConstantGroup[Null]

  56. object Operators extends AnyRef

  57. object OrVal extends Serializable

  58. object OrValMonoid extends Monoid[OrVal]

    Boolean OR monoid.

  59. object Predecessible extends Serializable

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

  61. object ResetState extends AnyRef

  62. object RichCBitSet extends AnyRef

  63. object RightFolded extends AnyRef

    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

  64. object RightFolded2 extends AnyRef

    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.

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

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

  67. object Ring extends GeneratedRingImplicits with ProductRings with Serializable

  68. object SGD extends AnyRef

  69. object SGDPos extends Serializable

  70. object SGDWeights extends Serializable

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

  72. object SSMany extends Serializable

  73. object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups with Serializable

  74. object ShortRing extends Ring[Short]

  75. object SketchMap extends Serializable

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

  76. object SketchMapParams extends Serializable

  77. object SortedTakeListMonoid extends Serializable

  78. object SpaceSaver extends AnyRef

  79. object StringMonoid extends Monoid[String]

  80. object Successible extends AnyRef

  81. object SummingCache extends Serializable

  82. object SummingIterator extends Serializable

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

  83. object SummingQueue extends Serializable

  84. object UnitGroup extends ConstantGroup[Unit]

  85. object VectorSpace extends Serializable

    This class represents a vector space.

  86. package javaapi

  87. package matrix

  88. package monad

  89. package mutable

  90. package statistics