Aggregator

Value Members

1. final def !=(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

4. implicit def applicative[I]: Applicative[[O]Aggregator[I, _, O]]

   

5. def approximatePercentile[T](percentile: Double, k: Int)(implicit num: Numeric[T]): QTreeAggregatorLowerBound[T]

   

   Returns the lower bound of a given percentile where the percentile is between (0,1] The items that are iterated over cannot be negative.

6. def approximatePercentileBounds[T](percentile: Double, k: Int)(implicit num: Numeric[T]): QTreeAggregator[T]

   

   Returns the intersection of a bounded percentile where the percentile is between (0,1] The items that are iterated over cannot be negative.

7. def approximateUniqueCount[T](implicit arg0: Hash128[T]): MonoidAggregator[T, Either[HLL, Set[T]], Long]

   

   Using a constant amount of memory, give an approximate unique count (~ 1% error).

   Using a constant amount of memory, give an approximate unique count (~ 1% error). This uses an exact set for up to 100 items, then HyperLogLog (HLL) with an 1.2% standard error which uses at most 8192 bytes for each HLL. For more control, see HyperLogLogAggregator.

8. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

9. def clone(): AnyRef

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

10. def const[T](t: T): MonoidAggregator[Any, Unit, T]

    

    This is a trivial aggregator that always returns a single value

11. def count[T](pred: (T) ⇒ Boolean): MonoidAggregator[T, Long, Long]

    

    How many items satisfy a predicate

12. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

13. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

14. def exists[T](pred: (T) ⇒ Boolean): MonoidAggregator[T, Boolean, Boolean]

    

    Do any items satisfy some predicate

15. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

16. def forall[T](pred: (T) ⇒ Boolean): MonoidAggregator[T, Boolean, Boolean]

    

    Do all items satisfy a predicate

17. def fromMonoid[F, T](implicit mon: Monoid[T], prep: (F) ⇒ T): MonoidAggregator[F, T, T]

    

18. def fromMonoid[T](implicit mon: Monoid[T]): MonoidAggregator[T, T, T]

    

19. def fromReduce[T](red: (T, T) ⇒ T): Aggregator[T, T, T]

    

    Using Aggregator.prepare,present you can add to this aggregator

20. def fromRing[F, T](implicit rng: Ring[T], prep: (F) ⇒ T): RingAggregator[F, T, T]

    

21. def fromRing[T](implicit rng: Ring[T]): RingAggregator[T, T, T]

    

22. def fromSemigroup[T](implicit sg: Semigroup[T]): Aggregator[T, T, T]

    

23. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

24. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

25. def head[T]: Aggregator[T, T, T]

    

    Take the first (left most in reduce order) item found

26. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

27. def last[T]: Aggregator[T, T, T]

    

    Take the last (right most in reduce order) item found

28. def max[T](implicit arg0: Ordering[T]): Aggregator[T, T, T]

    

    Get the maximum item

29. def maxBy[U, T](fn: (U) ⇒ T)(implicit arg0: Ordering[T]): Aggregator[U, U, U]

    

30. def min[T](implicit arg0: Ordering[T]): Aggregator[T, T, T]

    

    Get the minimum item

31. def minBy[U, T](fn: (U) ⇒ T)(implicit arg0: Ordering[T]): Aggregator[U, U, U]

    

32. final def ne(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

33. final def notify(): Unit

    

    Definition Classes

    AnyRef

34. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

35. def prepareMonoid[F, T](prep: (F) ⇒ T)(implicit m: Monoid[T]): MonoidAggregator[F, T, T]

    

36. def size: MonoidAggregator[Any, Long, Long]

    

    This returns the number of items we find

37. def sortedReverseTake[T](count: Int)(implicit arg0: Ordering[T]): MonoidAggregator[T, PriorityQueue[T], Seq[T]]

    

    Take the largest count items using a heap

38. def sortedTake[T](count: Int)(implicit arg0: Ordering[T]): MonoidAggregator[T, PriorityQueue[T], Seq[T]]

    

    Take the smallest count items using a heap

39. final def synchronized[T0](arg0: ⇒ T0): T0

    

    Definition Classes

    AnyRef

40. def toList[T]: MonoidAggregator[T, List[T], List[T]]

    

    Put everything in a List.

    Put everything in a List. Note, this could fill the memory if the List is very large.

41. def toSet[T]: MonoidAggregator[T, Set[T], Set[T]]

    

    Put everything in a Set.

    Put everything in a Set. Note, this could fill the memory if the Set is very large.

42. def toString(): String

    

    Definition Classes

    AnyRef → Any

43. def uniqueCount[T]: MonoidAggregator[T, Set[T], Int]

    

    This builds an in-memory Set, and then finally gets the size of that set.

    This builds an in-memory Set, and then finally gets the size of that set. This may not be scalable if the Uniques are very large. You might check the approximateUniqueCount or HyperLogLog Aggregator to get an approximate version of this that is scalable.

44. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

45. final def wait(arg0: Long, arg1: Int): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

46. final def wait(arg0: Long): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )