algebird

Type Members

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

For use from Java/minimizing code bloat in scala
case class AffineFunction[R](slope: R, intercept: R) extends Serializable with Product with Serializable

Represents functions of the kind: f(x) = slope * x + intercept
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.
trait Aggregator[-A, B, +C] extends (TraversableOnce[A]) ⇒ C with Serializable
case class Approximate[N](min: N, estimate: N, max: N, probWithinBounds: Double)(implicit numeric: Numeric[N]) extends Product with Serializable
case class ApproximateBoolean(isTrue: Boolean, withProb: Double) extends Product with Serializable
case class AveragedValue(count: Long, value: Double) extends Product with Serializable
sealed abstract class BF extends Serializable

Bloom Filter data structure
case class BFHash(numHashes: Int, width: Int, seed: Long = 0L) extends (String) ⇒ Iterable[Int] with Product with Serializable
case class BFInstance(hashes: BFHash, bits: BitSet, width: Int) extends BF with Product with Serializable
case class BFItem(item: String, hashes: BFHash, width: Int) extends BF with Product with Serializable

Bloom Filter with 1 value.
case class BFSparse(hashes: BFHash, bits: EWAHCompressedBitmap, width: Int) extends BF with Product with Serializable
case class BFZero(hashes: BFHash, width: Int) extends BF with Product with Serializable

Empty bloom filter.
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.
sealed abstract class CMS extends Serializable

The actual Count-Min sketch data structure.
case class CMSCountsTable(counts: Vector[Vector[Long]]) extends Product with Serializable

The 2-dimensional table of counters used in the Count-Min sketch.
case class CMSHash(a: Int, b: Int, width: Int) extends (Long) ⇒ Int with Product with Serializable

The Count-Min sketch uses pairwise independent hash functions drawn from a universal hashing family of the form
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.
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.
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.
case class CMSZero(params: CMSParams) extends CMS with Product with Serializable

Used for initialization.
class CassandraMurmurHash extends AnyRef
class ConstantGroup[T] extends Group[T]
class CountMinSketchMonoid extends Monoid[CMS]

Monoid for adding Count-Min sketches.
case class DecayedValue(value: Double, scaledTime: Double) extends Ordered[DecayedValue] with Product with Serializable
case class DecayedVector[C[_]](vector: C[Double], scaledTime: Double) extends Product with Serializable
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
class DivOp[T] extends AnyRef
class EitherMonoid[L, R] extends EitherSemigroup[L, R] with Monoid[Either[L, R]]
class EitherSemigroup[L, R] extends Semigroup[Either[L, R]]

Either semigroup is useful for error handling.
class EventuallyGroup[L, R] extends EventuallyMonoid[L, R] with Group[Either[L, R]]
class EventuallyMonoid[L, R] extends EventuallySemigroup[L, R] with Monoid[Either[L, R]]
class EventuallyRing[L, R] extends EventuallyGroup[L, R] with Ring[Either[L, R]]
class EventuallySemigroup[L, R] extends Semigroup[Either[L, R]]
trait Field[T] extends Ring[T]

Field: Ring + division.
case class First[+T](get: T) extends Product with Serializable
class Function1Monoid[T] extends Monoid[(T) ⇒ T]

Function1 monoid.
trait GeneratedGroupImplicits extends AnyRef
trait GeneratedMonoidImplicits extends AnyRef
trait GeneratedRingImplicits extends AnyRef
trait GeneratedSemigroupImplicits extends AnyRef
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).
sealed abstract class HLL extends Serializable
case class HeavyHitter(item: Long, count: Long) extends Product with Serializable
case class HeavyHitters(hhs: SortedSet[HeavyHitter] = ...) extends Product with Serializable

Containers for holding heavy hitter items and their associated counts.
class HyperLogLogMonoid extends Monoid[HLL]
class IndexedSeqGroup[T] extends IndexedSeqMonoid[T] with Group[IndexedSeq[T]]
class IndexedSeqMonoid[T] extends IndexedSeqSemigroup[T] with Monoid[IndexedSeq[T]]
class IndexedSeqRing[T] extends IndexedSeqGroup[T] with Ring[IndexedSeq[T]]
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]]
class JListMonoid[T] extends Monoid[List[T]]

Since Lists are mutable, this always makes a full copy.
class JMapMonoid[K, V] extends Monoid[Map[K, V]]

Since maps are mutable, this always makes a full copy.
case class Last[+T](get: T) extends Product with Serializable
class ListMonoid[T] extends Monoid[List[T]]

List concatenation monoid.
class MapGroup[K, V] extends MapMonoid[K, V] with Group[Map[K, V]]

You can think of this as a Sparse vector group
class MapMonoid[K, V] extends Monoid[Map[K, V]]

You can think of this as a Sparse vector monoid
class MapRing[K, V] extends MapGroup[K, V] with Ring[Map[K, V]]

You can think of this as a Sparse vector ring
case class Max[+T](get: T) extends Product with Serializable
trait Metric[-V] extends (V, V) ⇒ Double with Serializable

Annotations
@implicitNotFound( ... )
case class Min[+T](get: T) extends Product with Serializable
abstract class MinHasher[H] extends Monoid[Array[Byte]]

Instances of MinHasher can create, combine, and compare fixed-sized signatures of arbitrarily sized sets.
class MinHasher16 extends MinHasher[Char]
class MinHasher32 extends MinHasher[Int]
sealed abstract class MinPlus[+V] extends Serializable
class MinPlusSemiring[V] extends Ring[MinPlus[V]]
case class MinPlusValue[V](get: V) extends MinPlus[V] with Product with Serializable
class MinusOp[T] extends AnyRef
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.
trait Monad[M[_]] extends AnyRef

Simple implementation of a Monad type-class
class MonadField[T, M[_]] extends MonadRing[T, M] with Field[M[T]]
class MonadGroup[T, M[_]] extends MonadMonoid[T, M] with Group[M[T]]
class MonadMonoid[T, M[_]] extends MonadSemigroup[T, M] with Monoid[M[T]]
class MonadOperators[A, M[A]] extends AnyRef

This enrichment allows us to use our Monad instances in for expressions: if (import Monad.
class MonadRing[T, M[_]] extends MonadGroup[T, M] with Ring[M[T]]
class MonadSemigroup[T, M[_]] extends Semigroup[M[T]]
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
trait MonoidAggregator[-A, B, +C] extends Aggregator[A, B, C]
case class MurmurHash128(seed: Long) extends Product with Serializable
class OptionMonoid[T] extends Monoid[Option[T]]

Some(5) + Some(3) == Some(8) Some(5) + None == Some(5)
class PlusOp[T] extends AnyRef
class PureOp[A] extends AnyRef
class RichCBitSet extends AnyRef
class RichTraversable[T] extends AnyRef
sealed abstract class RightFolded[+In, +Out] extends AnyRef
sealed abstract class RightFolded2[+In, +Out, +Acc] extends AnyRef
class RightFolded2Monoid[In, Out, Acc] extends Monoid[RightFolded2[In, Out, Acc]]
case class RightFoldedToFold[+In](in: List[In]) extends RightFolded[In, Nothing] with Product with Serializable
case class RightFoldedToFold2[+In](in: List[In]) extends RightFolded2[In, Nothing, Nothing] with Product with Serializable
case class RightFoldedValue[+Out](v: Out) extends RightFolded[Nothing, Out] with Product with Serializable
case class RightFoldedValue2[+In, +Out, +Acc](v: Out, acc: Acc, rvals: List[In]) extends RightFolded2[In, Out, Acc] with Product with Serializable
trait Ring[T] extends Group[T]

Ring: Group + multiplication (see: http://en.
trait RingAggregator[-A, B, +C] extends Aggregator[A, B, C]
sealed abstract class SGD[+Pos] extends AnyRef
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.
case class SGDPos[+Pos](pos: List[Pos]) extends SGD[Pos] with Product with Serializable
case class SGDWeights(count: Long, weights: IndexedSeq[Double]) extends SGD[Nothing] with Product with Serializable
trait Semigroup[T] extends Serializable

Semigroup: This is a class with a plus method that is associative: a+(b+c) = (a+b)+c
class SeqMonoid[T] extends Monoid[Seq[T]]
class SetMonoid[T] extends Monoid[Set[T]]

Set union monoid.
case class SparseHLL(bits: Int, maxRhow: Map[Int, Max[Byte]]) extends HLL with Product with Serializable
trait StatefulSummer[V] extends Serializable

A Stateful summer is something that is potentially more efficient (a buffer, a cache, etc.
class SumAll[V] extends StatefulSummer[V]

Sum the entire iterator one item at a time.
class SummingCache[K, V] extends StatefulSummer[Map[K, V]]

A Stateful Summer on Map[K,V] that keeps a cache of recent keys
class SummingIterator[V] extends Serializable with Iterator[V]
class SummingQueue[V] extends (V) ⇒ Option[V] with StatefulSummer[V]
class TimesOp[T] extends AnyRef
case class TopK[N](size: Int, items: List[N], max: Option[N]) extends Product with Serializable
class TopKMonoid[T] extends Monoid[TopK[T]]

A top-k monoid that is much faster than SortedListTake equivalent to: (left ++ right).
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
class Tuple2Group[A, B] extends Group[(A, B)]

Combine 2 groups into a product group
class Tuple2Monoid[A, B] extends Monoid[(A, B)]

Combine 2 monoids into a product monoid
class Tuple2Ring[A, B] extends Ring[(A, B)]

Combine 2 rings into a product ring
class Tuple2Semigroup[A, B] extends Semigroup[(A, B)]

Combine 2 semigroups into a product semigroup
class Tuple3Group[A, B, C] extends Group[(A, B, C)]

Combine 3 groups into a product group
class Tuple3Monoid[A, B, C] extends Monoid[(A, B, C)]

Combine 3 monoids into a product monoid
class Tuple3Ring[A, B, C] extends Ring[(A, B, C)]

Combine 3 rings into a product ring
class Tuple3Semigroup[A, B, C] extends Semigroup[(A, B, C)]

Combine 3 semigroups into a product semigroup
class Tuple4Group[A, B, C, D] extends Group[(A, B, C, D)]

Combine 4 groups into a product group
class Tuple4Monoid[A, B, C, D] extends Monoid[(A, B, C, D)]

Combine 4 monoids into a product monoid
class Tuple4Ring[A, B, C, D] extends Ring[(A, B, C, D)]

Combine 4 rings into a product ring
class Tuple4Semigroup[A, B, C, D] extends Semigroup[(A, B, C, D)]

Combine 4 semigroups into a product semigroup
class Tuple5Group[A, B, C, D, E] extends Group[(A, B, C, D, E)]

Combine 5 groups into a product group
class Tuple5Monoid[A, B, C, D, E] extends Monoid[(A, B, C, D, E)]

Combine 5 monoids into a product monoid
class Tuple5Ring[A, B, C, D, E] extends Ring[(A, B, C, D, E)]

Combine 5 rings into a product ring
class Tuple5Semigroup[A, B, C, D, E] extends Semigroup[(A, B, C, D, E)]

Combine 5 semigroups into a product semigroup
class Tuple6Group[A, B, C, D, E, F] extends Group[(A, B, C, D, E, F)]

Combine 6 groups into a product group
class Tuple6Monoid[A, B, C, D, E, F] extends Monoid[(A, B, C, D, E, F)]

Combine 6 monoids into a product monoid
class Tuple6Ring[A, B, C, D, E, F] extends Ring[(A, B, C, D, E, F)]

Combine 6 rings into a product ring
class Tuple6Semigroup[A, B, C, D, E, F] extends Semigroup[(A, B, C, D, E, F)]

Combine 6 semigroups into a product semigroup
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
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
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
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
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
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
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
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
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
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
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
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
trait VectorSpace[F, C[_]] extends Serializable

Annotations
@implicitNotFound( ... )
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

object AffineFunction extends Serializable
object Approximate extends Serializable
object ApproximateBoolean extends Serializable
object AveragedGroup extends Group[AveragedValue]
object AveragedValue extends Serializable
object Averager extends MonoidAggregator[Double, AveragedValue, Double]
object BFInstance extends Serializable
object BloomFilter
object BooleanField extends Field[Boolean]
object CMS extends Serializable
object CMSCountsTable extends Serializable
object CMSInstance extends Serializable
object DecayedValue extends Serializable
object DecayedVector extends Serializable

Represents a container class together with time.
object DoubleField extends Field[Double]
object Field extends Serializable
object First extends Serializable
object FloatField extends Field[Float]
object Group extends GeneratedGroupImplicits with Serializable
object HeavyHitter extends Serializable
object HyperLogLog

Implementation of the HyperLogLog approximate counting as a Monoid
object IntRing extends Ring[Int]
object JBoolField extends Field[Boolean]
object JDoubleField extends Field[Double]
object JFloatField extends Field[Float]
object JIntRing extends Ring[Integer]
object JLongRing extends Ring[Long]
object JShortRing extends Ring[Short]
object Last extends Serializable
object LongRing extends Ring[Long]
object MapAlgebra
object Max extends Serializable
object Metric extends Serializable

A Metric[V] m is a function (V, V) => Double that satisfies the following properties:
object Min extends Serializable
object MinPlus extends Serializable
object MinPlusZero extends MinPlus[Nothing] with Product with Serializable
object Moments extends Serializable
object MomentsGroup extends Group[Moments]

A monoid to perform moment calculations.
object Monad

Follows the type-class pattern for the Monad trait
object Monoid extends GeneratedMonoidImplicits with Serializable
object NullGroup extends ConstantGroup[Null]
object Operators
object RichCBitSet
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
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.
object RightFoldedZero extends RightFolded[Nothing, Nothing] with Product with Serializable
object RightFoldedZero2 extends RightFolded2[Nothing, Nothing, Nothing] with Product with Serializable
object Ring extends GeneratedRingImplicits with Serializable
object SGD
object SGDPos extends Serializable
object SGDWeights extends Serializable
object SGDZero extends SGD[Nothing] with Product with Serializable
object Semigroup extends GeneratedSemigroupImplicits with Serializable
object ShortRing extends Ring[Short]
object SortedTakeListMonoid extends Serializable
object StringMonoid extends Monoid[String]
object SummingCache extends Serializable
object SummingIterator extends Serializable

Creates an Iterator that emits partial sums of an input Iterator[V].
object SummingQueue extends Serializable
object UnitGroup extends ConstantGroup[Unit]
object VectorSpace extends Serializable

This class represents a vector space.
package mutable

package algebird

Type Members

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

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

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

trait Aggregator[-A, B, +C] extends (TraversableOnce[A]) ⇒ C with Serializable

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

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

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

sealed abstract class BF extends Serializable

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

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

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

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

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

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

sealed abstract class CMS extends Serializable

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

case class CMSHash(a: Int, b: Int, width: Int) extends (Long) ⇒ Int with Product with Serializable

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

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

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

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

class CassandraMurmurHash extends AnyRef

class ConstantGroup[T] extends Group[T]

class CountMinSketchMonoid extends Monoid[CMS]

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

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

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

class DivOp[T] extends AnyRef

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

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

class EventuallyGroup[L, R] extends EventuallyMonoid[L, R] with Group[Either[L, R]]

class EventuallyMonoid[L, R] extends EventuallySemigroup[L, R] with Monoid[Either[L, R]]

class EventuallyRing[L, R] extends EventuallyGroup[L, R] with Ring[Either[L, R]]

class EventuallySemigroup[L, R] extends Semigroup[Either[L, R]]

trait Field[T] extends Ring[T]

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

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

trait GeneratedGroupImplicits extends AnyRef

trait GeneratedMonoidImplicits extends AnyRef

trait GeneratedRingImplicits extends AnyRef

trait GeneratedSemigroupImplicits extends AnyRef

trait Group[T] extends Monoid[T]

sealed abstract class HLL extends Serializable

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

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

class HyperLogLogMonoid extends Monoid[HLL]

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

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

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

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

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

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

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

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

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

class MapMonoid[K, V] extends Monoid[Map[K, V]]

class MapRing[K, V] extends MapGroup[K, V] with Ring[Map[K, V]]

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

trait Metric[-V] extends (V, V) ⇒ Double with Serializable

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

abstract class MinHasher[H] extends Monoid[Array[Byte]]

class MinHasher16 extends MinHasher[Char]

class MinHasher32 extends MinHasher[Int]

sealed abstract class MinPlus[+V] extends Serializable

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

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

class MinusOp[T] extends AnyRef

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

trait Monad[M[_]] extends AnyRef

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

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

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

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

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

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

trait Monoid[T] extends Semigroup[T]

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