object Averager extends MonoidAggregator[Double, AveragedValue, Double]
Aggregator that uses AveragedValue to calculate the mean
of all Double
values in the stream. Each Double value receives a
count of 1 during aggregation.
- Alphabetic
- By Inheritance
- Averager
- MonoidAggregator
- Aggregator
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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: (Double) ⇒ D): MonoidAggregator[Double, AveragedValue, D]
Like calling andThen on the present function
Like calling andThen on the present function
- Definition Classes
- MonoidAggregator → Aggregator
-
def
append(l: AveragedValue, r: Double): AveragedValue
- Definition Classes
- Aggregator
-
def
appendAll(items: TraversableOnce[Double]): AveragedValue
- Definition Classes
- MonoidAggregator
-
def
appendAll(old: AveragedValue, items: TraversableOnce[Double]): AveragedValue
- Definition Classes
- Aggregator
-
def
apply(inputs: TraversableOnce[Double]): Double
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[Double], Out](inputs: In)(implicit bf: CanBuildFrom[In, Double, 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[Double]): Option[Double]
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( ... ) @native()
-
def
collectBefore[A2](fn: PartialFunction[A2, Double]): MonoidAggregator[A2, AveragedValue, Double]
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) ⇒ Double): MonoidAggregator[A2, AveragedValue, Double]
Like calling compose on the prepare function
Like calling compose on the prepare function
- Definition Classes
- MonoidAggregator → Aggregator
-
def
cumulativeIterator(inputs: Iterator[Double]): Iterator[Double]
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[Double, A2], (AveragedValue, B2), (Double, 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
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
filterBefore[A1 <: Double](pred: (A1) ⇒ Boolean): MonoidAggregator[A1, AveragedValue, Double]
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[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
join[A2 <: Double, B2, C2](that: Aggregator[A2, B2, C2]): Aggregator[A2, (AveragedValue, B2), (Double, 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
-
def
lift: MonoidAggregator[Double, Option[AveragedValue], Option[Double]]
- Definition Classes
- Aggregator
-
val
monoid: AveragedGroup.type
- Definition Classes
- Averager → MonoidAggregator
-
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(value: Double): AveragedValue
- Definition Classes
- Averager → Aggregator
-
def
present(average: AveragedValue): Double
- Definition Classes
- Averager → Aggregator
-
final
def
reduce(items: TraversableOnce[AveragedValue]): AveragedValue
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: AveragedValue, r: AveragedValue): AveragedValue
combine two inner values
combine two inner values
- Definition Classes
- Aggregator
-
def
reduceOption(items: TraversableOnce[AveragedValue]): Option[AveragedValue]
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
-
def
semigroup: Monoid[AveragedValue]
- Definition Classes
- MonoidAggregator → Aggregator
-
def
sumBefore: MonoidAggregator[TraversableOnce[Double], AveragedValue, Double]
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[Double, Option[Double]]
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
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
zip[A2, B2, C2](ag2: MonoidAggregator[A2, B2, C2]): MonoidAggregator[(Double, A2), (AveragedValue, B2), (Double, 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[(Double, A2), (AveragedValue, B2), (Double, 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