algebird

Type Members

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

For use from Java/minimizing code bloat in scala
abstract class AbstractField[T] extends Field[T]
abstract class AbstractFunctor[M[_]] extends Functor[M]

For use from Java/minimizing code bloat in scala
abstract class AbstractGroup[T] extends Group[T]
abstract class AbstractMonad[M[_]] extends Monad[M]

For use from Java/minimizing code bloat in scala
abstract class AbstractMonoid[T] extends Monoid[T]
abstract class AbstractRing[T] extends Ring[T]
abstract class AbstractSemigroup[T] extends Semigroup[T]
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.
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.
class AdjoinedUnitRing[T] extends Ring[AdjoinedUnit[T]]
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 Serializable
final case class AndVal(get: Boolean) extends AnyVal with Product with Serializable
trait Applicative[M[_]] extends Functor[M]

Simple implementation of an Applicative type-class.
class ApplicativeOperators[A, M[_]] extends FunctorOperators[A, M]

This enrichment allows us to use our Applicative instances in for expressions: if (import Applicative.
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
abstract class ArrayBufferedOperation[I, O] extends Buffered[I, O]
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 BitSetLite(in: Array[Byte]) extends Product with Serializable

A super lightweight (hopefully) version of BitSet
case class BloomFilterAggregator(bfMonoid: BloomFilterMonoid) extends MonoidAggregator[String, BF, BF] with Product with Serializable
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.
trait Buffered[I, O] extends Serializable

Represents something that consumes I and may emit O.
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
class BufferedSumAll[V] extends ArrayBufferedOperation[V, V] with StatefulSummer[V] with BufferedReduce[V]
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 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]
case class CountMinSketchAggregator(cmsMonoid: CountMinSketchMonoid) extends MonoidAggregator[Long, CMS, CMS] with Product with Serializable

An Aggregator for the CountMinSketch.
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 DecayedValueMonoid(eps: Double) extends Monoid[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
case class DenseVector[V](iseq: Vector[V], sparseValue: V, denseCount: Int) extends AdaptiveVector[V] 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]]

Either semigroup is useful for error handling.
case class Empty[T]() extends Interval[T] with Product with Serializable
class EventuallyGroup[E, O] extends EventuallyMonoid[E, O] with Group[Either[E, O]]
class EventuallyMonoid[E, O] extends EventuallySemigroup[E, O] with Monoid[Either[E, O]]
class EventuallyRing[E, O] extends EventuallyGroup[E, O] with Ring[Either[E, O]]
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.
case class ExclusiveLower[T](lower: T)(implicit ordering: Ordering[T]) extends Interval[T] with Lower[T] with Product with Serializable
case class ExclusiveUpper[T](upper: T)(implicit ordering: Ordering[T]) extends Interval[T] with Upper[T] with Product with Serializable
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 Functor[M[_]] extends AnyRef

Simple implementation of a Functor type-class.
class FunctorOperators[A, M[_]] extends AnyRef

This enrichment allows us to use our Functor instances in for expressions: if (import Functor.
trait GeneratedGroupImplicits extends AnyRef
trait GeneratedMonoidImplicits extends AnyRef
trait GeneratedRingImplicits extends AnyRef
trait GeneratedSemigroupImplicits extends AnyRef
trait GeneratedTupleAggregator extends AnyRef
abstract class GenericMapMonoid[K, V, M <: Map[K, V]] extends Monoid[M] with MapOperations[K, V, M]
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
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
class HashingTrickMonoid[V] extends Monoid[AdaptiveVector[V]]
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.
case class HyperLogLogAggregator(hllMonoid: HyperLogLogMonoid) extends MonoidAggregator[Array[Byte], HLL, HLL] with Product with Serializable
class HyperLogLogMonoid extends Monoid[HLL]
case class InclusiveLower[T](lower: T)(implicit ordering: Ordering[T]) extends Interval[T] with Lower[T] with Product with Serializable
case class InclusiveUpper[T](upper: T)(implicit ordering: Ordering[T]) extends Interval[T] with Upper[T] with Product with Serializable
class IndexedSeqArrayByte extends IndexedSeq[Byte]
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 IntegralPredecessible[T] extends Predecessible[T]
class IntegralSuccessible[T] extends Successible[T]
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
sealed trait Interval[T] extends Serializable

Represents a single interval on a T with an Ordering
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.
sealed trait Lower[T] extends Interval[T]
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 GenericMapMonoid[K, V, Map[K, V]]
trait MapOperations[K, V, M <: Map[K, V]] extends AnyRef
class MapRing[K, V] extends MapGroup[K, V] with GenericMapRing[K, V, Map[K, V]]
case class Max[+T](get: T) extends Product with Serializable
case class MaxAggregator[T]()(implicit ord: Ordering[T]) extends Aggregator[T, T, T] with Product with Serializable
trait Metric[-V] extends Serializable

Annotations
@implicitNotFound( ... )
case class Min[+T](get: T) extends Product with Serializable
case class MinAggregator[T]()(implicit ord: Ordering[T]) extends Aggregator[T, T, T] with Product with Serializable
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].
abstract class MinHasher[H] extends Monoid[MinHashSignature]

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 trait MinPlus[+V] extends Serializable
class MinPlusSemiring[V] extends Ring[MinPlus[V]]
final case class MinPlusValue[V](get: V) extends AnyVal with 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 Applicative[M]

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[_]] extends ApplicativeOperators[A, M]

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]
class MonoidCombinator[A, B] extends SemigroupCombinator[A, B] with Monoid[(A, B)]
final case class MurmurHash128(seed: Long) extends AnyVal with Product with Serializable
class NumericRing[T] extends Ring[T]
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
class OptionMonoid[T] extends Monoid[Option[T]]

Some(5) + Some(3) == Some(8) Some(5) + None == Some(5)
final case class OrVal(get: Boolean) extends AnyVal with Product with Serializable
class PlusOp[T] extends AnyRef
trait Predecessible[T] extends Serializable

This is a typeclass to represent things which are countable down.
class Product10Group[X, A, B, C, D, E, F, G, H, I, J] extends Group[X]

Combine 10 groups into a product group
class Product10Monoid[X, A, B, C, D, E, F, G, H, I, J] extends Monoid[X]

Combine 10 monoids into a product monoid
class Product10Ring[X, A, B, C, D, E, F, G, H, I, J] extends Ring[X]

Combine 10 rings into a product ring
class Product10Semigroup[X, A, B, C, D, E, F, G, H, I, J] extends Semigroup[X]

Combine 10 semigroups into a product semigroup
class Product11Group[X, A, B, C, D, E, F, G, H, I, J, K] extends Group[X]

Combine 11 groups into a product group
class Product11Monoid[X, A, B, C, D, E, F, G, H, I, J, K] extends Monoid[X]

Combine 11 monoids into a product monoid
class Product11Ring[X, A, B, C, D, E, F, G, H, I, J, K] extends Ring[X]

Combine 11 rings into a product ring
class Product11Semigroup[X, A, B, C, D, E, F, G, H, I, J, K] extends Semigroup[X]

Combine 11 semigroups into a product semigroup
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
class Product2Group[X, A, B] extends Group[X]

Combine 2 groups into a product group
class Product2Monoid[X, A, B] extends Monoid[X]

Combine 2 monoids into a product monoid
class Product2Ring[X, A, B] extends Ring[X]

Combine 2 rings into a product ring
class Product2Semigroup[X, A, B] extends Semigroup[X]

Combine 2 semigroups into a product semigroup
class Product3Group[X, A, B, C] extends Group[X]

Combine 3 groups into a product group
class Product3Monoid[X, A, B, C] extends Monoid[X]

Combine 3 monoids into a product monoid
class Product3Ring[X, A, B, C] extends Ring[X]

Combine 3 rings into a product ring
class Product3Semigroup[X, A, B, C] extends Semigroup[X]

Combine 3 semigroups into a product semigroup
class Product4Group[X, A, B, C, D] extends Group[X]

Combine 4 groups into a product group
class Product4Monoid[X, A, B, C, D] extends Monoid[X]

Combine 4 monoids into a product monoid
class Product4Ring[X, A, B, C, D] extends Ring[X]

Combine 4 rings into a product ring
class Product4Semigroup[X, A, B, C, D] extends Semigroup[X]

Combine 4 semigroups into a product semigroup
class Product5Group[X, A, B, C, D, E] extends Group[X]

Combine 5 groups into a product group
class Product5Monoid[X, A, B, C, D, E] extends Monoid[X]

Combine 5 monoids into a product monoid
class Product5Ring[X, A, B, C, D, E] extends Ring[X]

Combine 5 rings into a product ring
class Product5Semigroup[X, A, B, C, D, E] extends Semigroup[X]

Combine 5 semigroups into a product semigroup
class Product6Group[X, A, B, C, D, E, F] extends Group[X]

Combine 6 groups into a product group
class Product6Monoid[X, A, B, C, D, E, F] extends Monoid[X]

Combine 6 monoids into a product monoid
class Product6Ring[X, A, B, C, D, E, F] extends Ring[X]

Combine 6 rings into a product ring
class Product6Semigroup[X, A, B, C, D, E, F] extends Semigroup[X]

Combine 6 semigroups into a product semigroup
class Product7Group[X, A, B, C, D, E, F, G] extends Group[X]

Combine 7 groups into a product group
class Product7Monoid[X, A, B, C, D, E, F, G] extends Monoid[X]

Combine 7 monoids into a product monoid
class Product7Ring[X, A, B, C, D, E, F, G] extends Ring[X]

Combine 7 rings into a product ring
class Product7Semigroup[X, A, B, C, D, E, F, G] extends Semigroup[X]

Combine 7 semigroups into a product semigroup
class Product8Group[X, A, B, C, D, E, F, G, H] extends Group[X]

Combine 8 groups into a product group
class Product8Monoid[X, A, B, C, D, E, F, G, H] extends Monoid[X]

Combine 8 monoids into a product monoid
class Product8Ring[X, A, B, C, D, E, F, G, H] extends Ring[X]

Combine 8 rings into a product ring
class Product8Semigroup[X, A, B, C, D, E, F, G, H] extends Semigroup[X]

Combine 8 semigroups into a product semigroup
class Product9Group[X, A, B, C, D, E, F, G, H, I] extends Group[X]

Combine 9 groups into a product group
class Product9Monoid[X, A, B, C, D, E, F, G, H, I] extends Monoid[X]

Combine 9 monoids into a product monoid
class Product9Ring[X, A, B, C, D, E, F, G, H, I] extends Ring[X]

Combine 9 rings into a product ring
class Product9Semigroup[X, A, B, C, D, E, F, G, H, I] extends Semigroup[X]

Combine 9 semigroups into a product semigroup
trait ProductGroups extends AnyRef
trait ProductMonoids extends AnyRef
trait ProductRings extends AnyRef
trait ProductSemigroups extends AnyRef
class PureOp[A] extends AnyRef
case class QTree[A](offset: Long, level: Int, count: Long, sum: A, lowerChild: Option[QTree[A]], upperChild: Option[QTree[A]])(implicit monoid: Monoid[A]) extends Product with Serializable
class QTreeSemigroup[A] extends Semigroup[QTree[A]]
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
class ResetStateMonoid[A] extends Monoid[ResetState[A]]
case class ResetValue[+A](get: A) extends ResetState[A] with Product with Serializable
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
case class SSMany[T](capacity: Int, counters: Map[T, (Long, Long)], buckets: SortedMap[Long, Set[T]]) extends SpaceSaver[T] with Product with Serializable
case class SSOne[T](capacity: Int, item: T) extends SpaceSaver[T] with Product with Serializable
class ScMapGroup[K, V] extends ScMapMonoid[K, V] with Group[Map[K, V]]
class ScMapMonoid[K, V] extends GenericMapMonoid[K, V, Map[K, V]]
class ScMapRing[K, V] extends ScMapGroup[K, V] with GenericMapRing[K, V, Map[K, V]]
trait Semigroup[T] extends Serializable

Semigroup: This is a class with a plus method that is associative: a+(b+c) = (a+b)+c
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.
class SeqMonoid[T] extends Monoid[Seq[T]]
class SetMonoid[T] extends Monoid[Set[T]]

Set union monoid.
case class SetValue[+A](get: A) extends ResetState[A] with Product with Serializable
case class SketchMap[K, V](valuesTable: AdaptiveMatrix[V], heavyHitterKeys: List[K], totalValue: V) extends Serializable with Product with Serializable
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.
case class SketchMapHash[K](hasher: CMSHash, seed: Int)(implicit serialization: (K) ⇒ Array[Byte]) extends Product with Serializable

Hashes an arbitrary key type to one that the Sketch Map can use.
class SketchMapMonoid[K, V] extends Monoid[SketchMap[K, V]]

Responsible for creating instances of SketchMap.
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.
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.
class SpaceSaverSemigroup[T] extends Semigroup[SpaceSaver[T]]
case class SparseHLL(bits: Int, maxRhow: Map[Int, Max[Byte]]) extends HLL with Product with Serializable
case class SparseVector[V](map: Map[Int, V], sparseValue: V, size: Int) extends AdaptiveVector[V] with Product with Serializable
trait StatefulSummer[V] extends Buffered[V, V]

A Stateful summer is something that is potentially more efficient (a buffer, a cache, etc.
trait Successible[T] extends AnyRef

This is a typeclass to represent things which increase.
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 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
case class Universe[T]() extends Interval[T] with Product with Serializable
sealed trait Upper[T] extends Interval[T]
trait VectorSpace[F, C[_]] extends Serializable

Annotations
@implicitNotFound( ... )

Value Members

object AdaptiveVector

Some functions to create or convert AdaptiveVectors
object AdjoinedUnit extends Serializable
object AffineFunction extends Serializable
object Aggregator extends Serializable

Aggregators compose well.
object AndVal extends Serializable
object AndValMonoid extends Monoid[AndVal]

Boolean AND monoid.
object Applicative

Follows the type-class pattern for the Applicative trait
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 BigIntRing extends NumericRing[BigInt]
object BloomFilter
object BloomFilterAggregator extends Serializable
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 Functor

Follows the type-class pattern for the Functor trait
object GeneratedTupleAggregator extends GeneratedTupleAggregator
object Group extends GeneratedGroupImplicits with ProductGroups with Serializable
object HeavyHitter extends Serializable
object HyperLogLog

Implementation of the HyperLogLog approximate counting as a Monoid
object HyperLogLogAggregator extends Serializable
object IntRing extends Ring[Int]
object Interval extends Serializable
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 MinHasher extends Serializable
object MinPlus extends Serializable
object MinPlusZero extends MinPlus[Nothing] with Product with Serializable
object Moments extends Serializable
object MomentsAggregator extends MonoidAggregator[Double, Moments, Moments]
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 ProductMonoids with Serializable
object NullGroup extends ConstantGroup[Null]
object Operators
object OrVal extends Serializable
object OrValMonoid extends Monoid[OrVal]

Boolean OR monoid.
object Predecessible extends Serializable
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).
object ResetState
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 ProductRings with Serializable
object SGD
object SGDPos extends Serializable
object SGDWeights extends Serializable
object SGDZero extends SGD[Nothing] with Product with Serializable
object SSMany extends Serializable
object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups with Serializable
object ShortRing extends Ring[Short]
object SketchMap extends Serializable

Data structure representing an approximation of Map[K, V], where V has an implicit ordering and monoid.
object SketchMapParams extends Serializable
object SpaceSaver
object StringMonoid extends Monoid[String]
object Successible
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 TopKMonoid extends Serializable
object UnitGroup extends ConstantGroup[Unit]
object VectorSpace extends Serializable

This class represents a vector space.
package javaapi
package matrix
package monad
package mutable
package statistics

package algebird

Type Members

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

abstract class AbstractField[T] extends Field[T]

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

abstract class AbstractGroup[T] extends Group[T]

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

abstract class AbstractMonoid[T] extends Monoid[T]

abstract class AbstractRing[T] extends Ring[T]

abstract class AbstractSemigroup[T] extends Semigroup[T]

sealed trait AdaptiveVector[V] extends IndexedSeq[V]

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

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

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 Serializable

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

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

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

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

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

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 BitSetLite(in: Array[Byte]) extends Product with Serializable

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

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

trait Buffered[I, O] extends Serializable

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

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

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

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

class CountMinSketchMonoid extends Monoid[CMS]

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

case class DecayedValueMonoid(eps: Double) extends Monoid[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

case class DenseVector[V](iseq: Vector[V], sparseValue: V, denseCount: Int) extends AdaptiveVector[V] 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]]

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

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

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

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

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

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

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

trait Field[T] extends Ring[T]

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

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

trait Functor[M[_]] extends AnyRef

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

trait GeneratedGroupImplicits extends AnyRef

trait GeneratedMonoidImplicits extends AnyRef

trait GeneratedRingImplicits extends AnyRef

trait GeneratedSemigroupImplicits extends AnyRef

trait GeneratedTupleAggregator extends AnyRef

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

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

trait Group[T] extends Monoid[T]

sealed abstract class HLL extends Serializable

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

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

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

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