case class SetSizeAggregator[A](hllBits: Int, maxSetSize: Int = 10)(implicit toBytes: (A) => Array[Byte]) extends SetSizeAggregatorBase[A] with Product with Serializable
- Alphabetic
- By Inheritance
- SetSizeAggregator
- Product
- Equals
- SetSizeAggregatorBase
- EventuallyMonoidAggregator
- MonoidAggregator
- AbstractEventuallyAggregator
- Aggregator
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new SetSizeAggregator(hllBits: Int, maxSetSize: Int = 10)(implicit toBytes: (A) => Array[Byte])
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def andThenPresent[D](present2: (Long) => D): MonoidAggregator[A, Either[HLL, Set[A]], D]
Like calling andThen on the present function
Like calling andThen on the present function
- Definition Classes
- MonoidAggregator → Aggregator
- def append(l: Either[HLL, Set[A]], r: A): Either[HLL, Set[A]]
- Definition Classes
- Aggregator
- def appendAll(items: TraversableOnce[A]): Either[HLL, Set[A]]
- Definition Classes
- MonoidAggregator
- def appendAll(old: Either[HLL, Set[A]], items: TraversableOnce[A]): Either[HLL, Set[A]]
- Definition Classes
- Aggregator
- def apply(inputs: TraversableOnce[A]): Long
This may error if inputs are empty (for Monoid Aggregators it never will, instead you see present(Monoid.zero[B])
This may error if inputs are empty (for Monoid Aggregators it never will, instead you see present(Monoid.zero[B])
- Definition Classes
- Aggregator
- def applyCumulatively[In <: TraversableOnce[A], Out](inputs: In)(implicit bf: CanBuildFrom[In, Long, Out]): Out
This returns the cumulative sum of its inputs, in the same order.
This returns the cumulative sum of its inputs, in the same order. If the inputs are empty, the result will be empty too.
- Definition Classes
- Aggregator
- def applyOption(inputs: TraversableOnce[A]): Option[Long]
This returns None if the inputs are empty
This returns None if the inputs are empty
- Definition Classes
- Aggregator
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collectBefore[A2](fn: PartialFunction[A2, A]): MonoidAggregator[A2, Either[HLL, Set[A]], Long]
Only transform values where the function is defined, else discard
Only transform values where the function is defined, else discard
- Definition Classes
- MonoidAggregator
- def composePrepare[A2](prepare2: (A2) => A): MonoidAggregator[A2, Either[HLL, Set[A]], Long]
Like calling compose on the prepare function
Like calling compose on the prepare function
- Definition Classes
- MonoidAggregator → Aggregator
- def convert(set: Set[A]): HLL
- Definition Classes
- SetSizeAggregator → AbstractEventuallyAggregator
- def cumulativeIterator(inputs: Iterator[A]): Iterator[Long]
This returns the cumulative sum of its inputs, in the same order.
This returns the cumulative sum of its inputs, in the same order. If the inputs are empty, the result will be empty too.
- Definition Classes
- Aggregator
- def either[A2, B2, C2](that: MonoidAggregator[A2, B2, C2]): MonoidAggregator[Either[A, A2], (Either[HLL, Set[A]], B2), (Long, C2)]
Build a MonoidAggregator that either takes left or right input and outputs the pair from both
Build a MonoidAggregator that either takes left or right input and outputs the pair from both
- Definition Classes
- MonoidAggregator
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def filterBefore[A1 <: A](pred: (A1) => Boolean): MonoidAggregator[A1, Either[HLL, Set[A]], Long]
Only aggregate items that match a predicate
Only aggregate items that match a predicate
- Definition Classes
- MonoidAggregator
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- val hllBits: Int
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def join[A2 <: A, B2, C2](that: Aggregator[A2, B2, C2]): Aggregator[A2, (Either[HLL, Set[A]], B2), (Long, C2)]
This allows you to run two aggregators on the same data with a single pass
This allows you to run two aggregators on the same data with a single pass
- Definition Classes
- Aggregator
- val leftSemigroup: HyperLogLogMonoid
- Definition Classes
- SetSizeAggregatorBase → AbstractEventuallyAggregator
- def lift: MonoidAggregator[A, Option[Either[HLL, Set[A]]], Option[Long]]
- Definition Classes
- Aggregator
- val maxSetSize: Int
- lazy val monoid: EventuallyMonoid[HLL, Set[A]]
- Definition Classes
- EventuallyMonoidAggregator → MonoidAggregator
- Annotations
- @transient()
- def mustConvert(set: Set[A]): Boolean
- Definition Classes
- SetSizeAggregatorBase → AbstractEventuallyAggregator
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def prepare(a: A): Right[HLL, Set[A]]
- Definition Classes
- AbstractEventuallyAggregator → Aggregator
- def present(b: Either[HLL, Set[A]]): Long
- Definition Classes
- AbstractEventuallyAggregator → Aggregator
- def presentLeft(hll: HLL): Long
- Definition Classes
- SetSizeAggregatorBase → AbstractEventuallyAggregator
- def productElementNames: Iterator[String]
- Definition Classes
- Product
- final def reduce(items: TraversableOnce[Either[HLL, Set[A]]]): Either[HLL, Set[A]]
This may error if items is empty.
This may error if items is empty. To be safe you might use reduceOption if you don't know that items is non-empty
- Definition Classes
- MonoidAggregator → Aggregator
- def reduce(l: Either[HLL, Set[A]], r: Either[HLL, Set[A]]): Either[HLL, Set[A]]
combine two inner values
combine two inner values
- Definition Classes
- Aggregator
- def reduceOption(items: TraversableOnce[Either[HLL, Set[A]]]): Option[Either[HLL, Set[A]]]
This is the safe version of the above.
This is the safe version of the above. If the input in empty, return None, else reduce the items
- Definition Classes
- Aggregator
- val rightAggregator: MonoidAggregator[A, Set[A], Long]
- Definition Classes
- SetSizeAggregatorBase → EventuallyMonoidAggregator → AbstractEventuallyAggregator
- def semigroup: Monoid[Either[HLL, Set[A]]]
- Definition Classes
- MonoidAggregator → Aggregator
- def sumBefore: MonoidAggregator[TraversableOnce[A], Either[HLL, Set[A]], Long]
This maps the inputs to Bs, then sums them, effectively flattening the inputs to the MonoidAggregator
This maps the inputs to Bs, then sums them, effectively flattening the inputs to the MonoidAggregator
- Definition Classes
- MonoidAggregator
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toFold: Fold[A, Option[Long]]
An Aggregator can be converted to a Fold, but not vice-versa Note, a Fold is more constrained so only do this if you require joining a Fold with an Aggregator to produce a Fold
An Aggregator can be converted to a Fold, but not vice-versa Note, a Fold is more constrained so only do this if you require joining a Fold with an Aggregator to produce a Fold
- Definition Classes
- Aggregator
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def zip[A2, B2, C2](ag2: MonoidAggregator[A2, B2, C2]): MonoidAggregator[(A, A2), (Either[HLL, Set[A]], B2), (Long, C2)]
This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .composePrepare onto the result if you have an initial input that has to be prepared differently for each of the joined aggregators.
This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .composePrepare onto the result if you have an initial input that has to be prepared differently for each of the joined aggregators.
The law here is: ag1.zip(ag2).apply(as.zip(bs)) == (ag1(as), ag2(bs))
- Definition Classes
- MonoidAggregator
- def zip[A2, B2, C2](ag2: Aggregator[A2, B2, C2]): Aggregator[(A, A2), (Either[HLL, Set[A]], B2), (Long, C2)]
This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .composePrepare onto the result if you have an initial input that has to be prepared differently for each of the joined aggregators.
This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .composePrepare onto the result if you have an initial input that has to be prepared differently for each of the joined aggregators.
The law here is: ag1.zip(ag2).apply(as.zip(bs)) == (ag1(as), ag2(bs))
- Definition Classes
- Aggregator