Value Members

1.  def Histogram[DATUM](num: Int, low: Double, high: Double, quantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM]): Selecting[DATUM, Binning[DATUM, Counting, Counting, Counting, Counting]]

   Convenience function for creating a conventional histogram.

2.  def Profile[DATUM](num: Int, low: Double, high: Double, binnedQuantity: UserFcn[DATUM, Double], averagedQuantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM]): Selecting[DATUM, Binning[DATUM, Averaging[DATUM], Counting, Counting, Counting]]

   Convenience function for creating binwise averages.

3.  def ProfileErr[DATUM](num: Int, low: Double, high: Double, binnedQuantity: UserFcn[DATUM, Double], averagedQuantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM]): Selecting[DATUM, Binning[DATUM, Deviating[DATUM], Counting, Counting, Counting]]

   Convenience function for creating a physicist's "profile plot," which is a Profile with variances.

4.  def SparselyHistogram[DATUM](binWidth: Double, quantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM], origin: Double = 0.0): Selecting[DATUM, SparselyBinning[DATUM, Counting, Counting]]

   Convenience function for creating a sparsely binned histogram.

5.  def SparselyProfile[DATUM](binWidth: Double, binnedQuantity: UserFcn[DATUM, Double], averagedQuantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM], origin: Double = 0.0): Selecting[DATUM, SparselyBinning[DATUM, Averaging[DATUM], Counting]]

   Convenience function for creating sparsely binned binwise averages.

6.  def SparselyProfileErr[DATUM](binWidth: Double, binnedQuantity: UserFcn[DATUM, Double], averagedQuantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM], origin: Double = 0.0): Selecting[DATUM, SparselyBinning[DATUM, Deviating[DATUM], Counting]]

   Convenience function for creating a physicist's sparsely binned "profile plot," which is a Profile with variances.

7.  def TwoDimensionallyHistogram[DATUM](xnum: Int, xlow: Double, xhigh: Double, xquantity: UserFcn[DATUM, Double], ynum: Int, ylow: Double, yhigh: Double, yquantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM]): Selecting[DATUM, Binning[DATUM, Binning[DATUM, Counting, Counting, Counting, Counting], Counting, Counting, Counting]]

   Convenience function for creating a conventional, two-dimensional histogram.

8.  def TwoDimensionallySparselyHistogram[DATUM](xbinWidth: Double, xquantity: UserFcn[DATUM, Double], ybinWidth: Double, yquantity: UserFcn[DATUM, Double], selection: UserFcn[DATUM, Double] = unweighted[DATUM], xorigin: Double = 0.0, yorigin: Double = 0.0): Selecting[DATUM, SparselyBinning[DATUM, SparselyBinning[DATUM, Counting, Counting], Counting]]

   Convenience function for creating a sparsely binned, two-dimensional histogram.

9.  implicit def anyBinnedMixedToStackedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with NoAggregation](hist: Stacked[Binning[DATUM, Counting, U, O, N], SN]): StackedHistogramMethods
10.  implicit def anyBinnedToFractionedHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Fractioned[Binned[Counted, U, O, N], Binned[Counted, U, O, N]]): FractionedHistogramMethods
11.  implicit def anyBinnedToHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Binned[Counted, U, O, N]): HistogramMethods
12.  implicit def anyBinnedToPartitionedHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: IrregularlyBinned[Binned[Counted, U, O, N], SN]): PartitionedHistogramMethods
13.  implicit def anyBinnedToProfileErrMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Binned[Deviated, U, O, N]): ProfileErrMethods
14.  implicit def anyBinnedToProfileMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Binned[Averaged, U, O, N]): ProfileMethods
15.  implicit def anyBinnedToStackedHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: Stacked[Binned[Counted, U, O, N], SN]): StackedHistogramMethods
16.  implicit def anyBinningToFractionedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Fractioning[DATUM, Binning[DATUM, Counting, U, O, N]]): FractionedHistogramMethods
17.  implicit def anyBinningToHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Binning[DATUM, Counting, U, O, N]): HistogramMethods
18.  implicit def anyBinningToPartitionedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: IrregularlyBinning[DATUM, Binning[DATUM, Counting, U, O, N], SN]): PartitionedHistogramMethods
19.  implicit def anyBinningToProfileErrMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Binning[DATUM, Deviating[DATUM], U, O, N]): ProfileErrMethods
20.  implicit def anyBinningToProfileMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Binning[DATUM, Averaging[DATUM], U, O, N]): ProfileMethods
21.  implicit def anyBinningToStackedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: Stacking[DATUM, Binning[DATUM, Counting, U, O, N], SN]): StackedHistogramMethods
22.  implicit def anySelectedBinnedMixedToStackedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with NoAggregation](hist: Stacked[Selecting[DATUM, Binning[DATUM, Counting, U, O, N]], SN]): StackedHistogramMethods
23.  implicit def anySelectedBinnedToFractionedHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Fractioned[Selected[Binned[Counted, U, O, N]], Selected[Binned[Counted, U, O, N]]]): FractionedHistogramMethods
24.  implicit def anySelectedBinnedToHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Selected[Binned[Counted, U, O, N]]): HistogramMethods
25.  implicit def anySelectedBinnedToPartitionedHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: IrregularlyBinned[Selected[Binned[Counted, U, O, N]], SN]): PartitionedHistogramMethods
26.  implicit def anySelectedBinnedToProfileErrMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Selected[Binned[Deviated, U, O, N]]): ProfileErrMethods
27.  implicit def anySelectedBinnedToProfileMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation](hist: Selected[Binned[Averaged, U, O, N]]): ProfileMethods
28.  implicit def anySelectedBinnedToStackedHistogramMethods[U <: Container[U] with NoAggregation, O <: Container[O] with NoAggregation, N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: Stacked[Selected[Binned[Counted, U, O, N]], SN]): StackedHistogramMethods
29.  implicit def anySelectedSparselyBinnedMixedToStackedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with NoAggregation](hist: Stacked[Selecting[DATUM, SparselyBinning[DATUM, Counting, N]], SN]): StackedHistogramMethods
30.  implicit def anySelectedSparselyBinnedToFractionedHistogramMethods[N <: Container[N] with NoAggregation](hist: Fractioned[Selected[SparselyBinned[Counted, N]], Selected[SparselyBinned[Counted, N]]]): FractionedHistogramMethods
31.  implicit def anySelectedSparselyBinnedToHistogramMethods[N <: Container[N] with NoAggregation](hist: Selected[SparselyBinned[Counted, N]]): HistogramMethods
32.  implicit def anySelectedSparselyBinnedToPartitionedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: IrregularlyBinned[Selected[SparselyBinned[Counted, N]], SN]): PartitionedHistogramMethods
33.  implicit def anySelectedSparselyBinnedToProfileErrMethods[N <: Container[N] with NoAggregation](hist: Selected[SparselyBinned[Deviated, N]]): ProfileErrMethods
34.  implicit def anySelectedSparselyBinnedToProfileMethods[N <: Container[N] with NoAggregation](hist: Selected[SparselyBinned[Averaged, N]]): ProfileMethods
35.  implicit def anySelectedSparselyBinnedToStackedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: Stacked[Selected[SparselyBinned[Counted, N]], SN]): StackedHistogramMethods
36.  implicit def anySelectingBinningToFractionedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Fractioning[DATUM, Selecting[DATUM, Binning[DATUM, Counting, U, O, N]]]): FractionedHistogramMethods
37.  implicit def anySelectingBinningToHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, Binning[DATUM, Counting, U, O, N]]): HistogramMethods
38.  implicit def anySelectingBinningToPartitionedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: IrregularlyBinning[DATUM, Selecting[DATUM, Binning[DATUM, Counting, U, O, N]], SN]): PartitionedHistogramMethods
39.  implicit def anySelectingBinningToProfileErrMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, Binning[DATUM, Deviating[DATUM], U, O, N]]): ProfileErrMethods
40.  implicit def anySelectingBinningToProfileMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, Binning[DATUM, Averaging[DATUM], U, O, N]]): ProfileMethods
41.  implicit def anySelectingBinningToStackedHistogramMethods[DATUM, U <: Container[U] with Aggregation { type Datum >: DATUM }, O <: Container[O] with Aggregation { type Datum >: DATUM }, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: Stacking[DATUM, Selecting[DATUM, Binning[DATUM, Counting, U, O, N]], SN]): StackedHistogramMethods
42.  implicit def anySelectingSparselyBinningToFractionedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Fractioning[DATUM, Selecting[DATUM, SparselyBinning[DATUM, Counting, N]]]): FractionedHistogramMethods
43.  implicit def anySelectingSparselyBinningToHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, SparselyBinning[DATUM, Counting, N]]): HistogramMethods
44.  implicit def anySelectingSparselyBinningToPartitionedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: IrregularlyBinning[DATUM, Selecting[DATUM, SparselyBinning[DATUM, Counting, N]], SN]): PartitionedHistogramMethods
45.  implicit def anySelectingSparselyBinningToProfileErrMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, SparselyBinning[DATUM, Deviating[DATUM], N]]): ProfileErrMethods
46.  implicit def anySelectingSparselyBinningToProfileMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, SparselyBinning[DATUM, Averaging[DATUM], N]]): ProfileMethods
47.  implicit def anySelectingSparselyBinningToStackedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: Stacking[DATUM, Selecting[DATUM, SparselyBinning[DATUM, Counting, N]], SN]): StackedHistogramMethods
48.  implicit def anySparselyBinnedMixedToStackedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with NoAggregation](hist: Stacked[SparselyBinning[DATUM, Counting, N], SN]): StackedHistogramMethods
49.  implicit def anySparselyBinnedToFractionedHistogramMethods[N <: Container[N] with NoAggregation](hist: Fractioned[SparselyBinned[Counted, N], SparselyBinned[Counted, N]]): FractionedHistogramMethods
50.  implicit def anySparselyBinnedToHistogramMethods[N <: Container[N] with NoAggregation](hist: SparselyBinned[Counted, N]): HistogramMethods
51.  implicit def anySparselyBinnedToPartitionedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: IrregularlyBinned[SparselyBinned[Counted, N], SN]): PartitionedHistogramMethods
52.  implicit def anySparselyBinnedToProfileErrMethods[N <: Container[N] with NoAggregation](hist: SparselyBinned[Deviated, N]): ProfileErrMethods
53.  implicit def anySparselyBinnedToProfileMethods[N <: Container[N] with NoAggregation](hist: SparselyBinned[Averaged, N]): ProfileMethods
54.  implicit def anySparselyBinnedToStackedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: Stacked[SparselyBinned[Counted, N], SN]): StackedHistogramMethods
55.  implicit def anySparselyBinningToFractionedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Fractioning[DATUM, SparselyBinning[DATUM, Counting, N]]): FractionedHistogramMethods
56.  implicit def anySparselyBinningToHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: SparselyBinning[DATUM, Counting, N]): HistogramMethods
57.  implicit def anySparselyBinningToPartitionedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: IrregularlyBinning[DATUM, SparselyBinning[DATUM, Counting, N], SN]): PartitionedHistogramMethods
58.  implicit def anySparselyBinningToProfileErrMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: SparselyBinning[DATUM, Deviating[DATUM], N]): ProfileErrMethods
59.  implicit def anySparselyBinningToProfileMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: SparselyBinning[DATUM, Averaging[DATUM], N]): ProfileMethods
60.  implicit def anySparselyBinningToStackedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }, SN <: Container[SN] with Aggregation { type Datum >: DATUM }](hist: Stacking[DATUM, SparselyBinning[DATUM, Counting, N], SN]): StackedHistogramMethods
61.  implicit def binnedToTwoDimensionallyHistogramMethods[UX <: Container[UX] with NoAggregation, OX <: Container[OX] with NoAggregation, NX <: Container[NX] with NoAggregation, UY <: Container[UY] with NoAggregation, OY <: Container[OY] with NoAggregation, NY <: Container[NY] with NoAggregation](hist: Binned[Binned[Counted, UY, OY, NY], UX, OX, NX]): TwoDimensionallyHistogramMethods
62.  implicit def binningToTwoDimensionallyHistogramMethods[DATUM, UX <: Container[UX] with Aggregation { type Datum >: DATUM }, OX <: Container[OX] with Aggregation { type Datum >: DATUM }, NX <: Container[NX] with Aggregation { type Datum >: DATUM }, UY <: Container[UY] with Aggregation { type Datum >: DATUM }, OY <: Container[OY] with Aggregation { type Datum >: DATUM }, NY <: Container[NY] with Aggregation { type Datum >: DATUM }](hist: Binning[DATUM, Binning[DATUM, Counting, UY, OY, NY], UX, OX, NX]): TwoDimensionallyHistogramMethods
63.  implicit def branchedToCollectionMethods(branched: Branched[_, _]): CollectionMethods
64.  implicit def branchingToCollectionMethods(branching: Branching[_, _]): CollectionMethods
65.  def help: String

    Help function for interactive use.

    Help function for interactive use. Used to discover container types.

66.  implicit def indexedToCollectionMethods(indexed: Indexed[_]): CollectionMethods
67.  implicit def indexingToCollectionMethods(indexing: Indexing[_]): CollectionMethods
68.  implicit def labeledToCollectionMethods(labeled: Labeled[_]): CollectionMethods
69.  implicit def labelingToCollectionMethods(labeling: Labeling[_]): CollectionMethods
70.  implicit def selectedBinnedToTwoDimensionallyHistogramMethods[UX <: Container[UX] with NoAggregation, OX <: Container[OX] with NoAggregation, NX <: Container[NX] with NoAggregation, UY <: Container[UY] with NoAggregation, OY <: Container[OY] with NoAggregation, NY <: Container[NY] with NoAggregation](hist: Selected[Binned[Binned[Counted, UY, OY, NY], UX, OX, NX]]): TwoDimensionallyHistogramMethods
71.  implicit def selectedSparselyBinnedToTwoDimensionallyHistogramMethods[NX <: Container[NX] with NoAggregation, NY <: Container[NY] with NoAggregation](hist: Selected[SparselyBinned[SparselyBinned[Counted, NY], NX]]): TwoDimensionallyHistogramMethods
72.  implicit def selectingBinningToTwoDimensionallyHistogramMethods[DATUM, UX <: Container[UX] with Aggregation { type Datum >: DATUM }, OX <: Container[OX] with Aggregation { type Datum >: DATUM }, NX <: Container[NX] with Aggregation { type Datum >: DATUM }, UY <: Container[UY] with Aggregation { type Datum >: DATUM }, OY <: Container[OY] with Aggregation { type Datum >: DATUM }, NY <: Container[NY] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, Binning[DATUM, Binning[DATUM, Counting, UY, OY, NY], UX, OX, NX]]): TwoDimensionallyHistogramMethods
73.  implicit def selectingSparselyBinningToTwoDimensionallyHistogramMethods[DATUM, NX <: Container[NX] with Aggregation { type Datum >: DATUM }, NY <: Container[NY] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, SparselyBinning[DATUM, SparselyBinning[DATUM, Counting, NY], NX]]): TwoDimensionallyHistogramMethods
74.  implicit def sparselyBinnedToTwoDimensionallyHistogramMethods[NX <: Container[NX] with NoAggregation, NY <: Container[NY] with NoAggregation](hist: SparselyBinned[SparselyBinned[Counted, NY], NX]): TwoDimensionallyHistogramMethods
75.  implicit def sparselyBinningToTwoDimensionallyHistogramMethods[DATUM, NX <: Container[NX] with Aggregation { type Datum >: DATUM }, NY <: Container[NY] with Aggregation { type Datum >: DATUM }](hist: SparselyBinning[DATUM, SparselyBinning[DATUM, Counting, NY], NX]): TwoDimensionallyHistogramMethods
76.  implicit def untypedLabeledToCollectionMethods(untypedLabeled: UntypedLabeled): CollectionMethods
77.  implicit def untypedLabelingToCollectionMethods(untypedLabeling: UntypedLabeling[_]): CollectionMethods
78.  def unweighted[DATUM]: Unweighted[DATUM]

    Default weighting function that always returns 1.0.

79.  object Average extends Factory

    Accumulate the weighted mean of a given quantity.

    Accumulate the weighted mean of a given quantity.

    Uses the numerically stable weighted mean algorithm described in Tony Finch, "Incremental calculation of weighted mean and variance" Univeristy of Cambridge Computing Service, 2009.

    Factory produces mutable org.dianahep.histogrammar.Averaging and immutable org.dianahep.histogrammar.Averaged objects.

80.  object Bag extends Factory

    Accumulate raw numbers, vectors of numbers, or strings, with identical values merged.

    Accumulate raw numbers, vectors of numbers, or strings, with identical values merged.

    A bag is the appropriate data type for scatter plots: a container that collects raw values, maintaining multiplicity but not order. (A "bag" is also known as a "multiset.") Conceptually, it is a mapping from distinct raw values to the number of observations: when two instances of the same raw value are observed, one key is stored and their weights add.

    Although the user-defined function may return scalar numbers, fixed-dimension vectors of numbers, or categorical strings, it may not mix range types. For the purposes of Label and Index (which can only collect aggregators of a single type), bags with different ranges are different types.

    Factory produces mutable org.dianahep.histogrammar.Bagging and immutable org.dianahep.histogrammar.Bagged objects.

81.  object Bin extends Factory

    Split a quantity into equally spaced bins between a low and high threshold and fill exactly one bin per datum.

    Split a quantity into equally spaced bins between a low and high threshold and fill exactly one bin per datum.

    When composed with org.dianahep.histogrammar.Count, this produces a standard histogram:

    Bin.ing(100, 0, 10, fill_x, Count.ing())

    and when nested, it produces a two-dimensional histogram:

    Bin.ing(100, 0, 10, fill_x,
      Bin.ing(100, 0, 10, fill_y, Count.ing()))

    Combining with org.dianahep.histogrammar.Deviate produces a physicist's "profile plot:"

    Bin.ing(100, 0, 10, fill_x, Deviate.ing(fill_y))

    and so on.

    Factory produces mutable org.dianahep.histogrammar.Binning and immutable org.dianahep.histogrammar.Binned objects.

82.  object Branch extends Factory

    Accumulate aggregators of different types, indexed by i0 through i9.

    Accumulate aggregators of different types, indexed by i0 through i9. Every sub-aggregator is filled with every input datum.

    This primitive provides an anonymous collection of aggregators of different types, usually for gluing together various statistics. For instance, if the following associates a sum of weights to every bin in a histogram,

    Bin.ing(100, 0, 1, {d: Datum => d.x},
      Sum.ing({d: Datum => d.weight}))

    the following would associate the sum of weights and the sum of squared weights to every bin:

    Bin.ing(100, 0, 1, {d: Datum => d.x},
      Branch.ing(Sum.ing({d: Datum => d.weight}),
                 Sum.ing({d: Datum => d.weight*d.weight})))

    Branch is a basic building block for complex aggregators. The limitation to ten branches, indexed from i0 to i9, is a concession to type inference in statically typed languages. It is not a fundamental limit, but the type-metaprogramming becomes increasingly complex as branches are added. Error messages may be convoluted as the compiler presents internals of the type-metaprogramming in response to a user's simple mistake.

    Therefore, individual implementations may allow more than ten branches, but the Histogrammar standard only requires ten.

    To collect an unlimited number of aggregators of the same type without naming them, use org.dianahep.histogrammar.Index. To collect aggregators of the same type with string-based labels, use org.dianahep.histogrammar.Label. To collect aggregators of different types with string-based labels, use org.dianahep.histogrammar.UntypedLabel.

    Factory produces mutable org.dianahep.histogrammar.Branching and immutable org.dianahep.histogrammar.Branched objects.

    Note: there is nothing intrinsic about the limit of 10 items. The data themselves are stored in a linked list (in value space and type space) and index fields i0 through i9 are added implicitly to lists of type-length 2 through 10, respectively. Longer lists can be created by adding more implicit methods.

    To create a Branched, do Branch.ed(entries, h1, h2, h3, ...).

    To create a Branching, do Branch(h1, h2, h3, ...).

83.  object BranchedNil extends BranchedList with Serializable
84.  object BranchingNil extends BranchingList with Serializable
85.  object Categorize extends Factory

    Split a given quantity by its categorical value and fill only one category per datum.

    Split a given quantity by its categorical value and fill only one category per datum.

    A bar chart may be thought of as a histogram with string-valued (categorical) bins, so this is the equivalent of org.dianahep.histogrammar.Bin for bar charts. The order of the strings is deferred to the visualization stage.

    Unlike org.dianahep.histogrammar.SparselyBin, this aggregator has the potential to use unlimited memory. A large number of distinct categories can generate many unwanted bins.

    Factory produces mutable org.dianahep.histogrammar.Categorizing and immutable org.dianahep.histogrammar.Categorized objects.

86.  object CentrallyBin extends Factory

    Split a quantity into bins defined by irregularly spaced bin centers, with exactly one sub-aggregator filled per datum (the closest one).

    Split a quantity into bins defined by irregularly spaced bin centers, with exactly one sub-aggregator filled per datum (the closest one).

    Unlike irregular bins defined by explicit ranges, irregular bins defined by bin centers are guaranteed to fully partition the space with no gaps and no overlaps. It could be viewed as cluster scoring in one dimension.

    Factory produces mutable org.dianahep.histogrammar.CentrallyBinning and immutable org.dianahep.histogrammar.CentrallyBinned objects.

87.  object Count extends Factory

    Count entries by accumulating the sum of all observed weights or a sum of transformed weights (e.g.

    Count entries by accumulating the sum of all observed weights or a sum of transformed weights (e.g. sum of squares of weights).

    An optional transform function can be applied to the weights before summing. To accumulate the sum of squares of weights, use {x: Double => x*x}, for instance. This is unlike any other primitive's quantity function in that its domain is the weights (always double), not data (any type).

    Factory produces mutable org.dianahep.histogrammar.Counting and immutable org.dianahep.histogrammar.Counted objects.

88.  object Deviate extends Factory

    Accumulate the weighted mean and weighted variance of a given quantity.

    Accumulate the weighted mean and weighted variance of a given quantity.

    The variance is computed around the mean, not zero.

    Uses the numerically stable weighted mean and weighted variance algorithms described in Tony Finch, "Incremental calculation of weighted mean and variance" Univeristy of Cambridge Computing Service, 2009.

    Factory produces mutable org.dianahep.histogrammar.Deviating and immutable org.dianahep.histogrammar.Deviated objects.

89.  object Factory

    Entry point for constructing containers from JSON and centralized registry of container types.

    Entry point for constructing containers from JSON and centralized registry of container types.

    Containers filled in Python or on remote sites are serialized as JSON that the Factory object can reconstruct. Reconstructed containers are fixed (immutable, cannot aggregate), but can be merged with the + operator. (Click on the "o" in a circle in the upper-left to see the Factory trait's documentation, which explains the difference.)

    To do this, the Factory object must dispatch JSON to the appropriate container for interpretation. It therefore manages a global registry of container types (concrete instances of the Factory trait). General users are not expected to add to this registry, but they could if they want to.

90.  object Fraction extends Factory

    Accumulate two aggregators, one containing only entries that pass a given selection (numerator) and another that contains all entries (denominator).

    Accumulate two aggregators, one containing only entries that pass a given selection (numerator) and another that contains all entries (denominator).

    The aggregator may be a simple org.dianahep.histogrammar.Count to measure the efficiency of a cut, a org.dianahep.histogrammar.Bin to plot a turn-on curve, or anything else to be tested with and without a cut.

    As a side effect of NaN values returning false for any comparison, a NaN return value from the selection is treated as a failed cut (the denominator is filled but the numerator is not).

    Factory produces mutable org.dianahep.histogrammar.Fractioning and immutable org.dianahep.histogrammar.Fractioned objects.

91.  object Index extends Factory

    Accumulate any number of aggregators of the same type in a list.

    Accumulate any number of aggregators of the same type in a list. Every sub-aggregator is filled with every input datum.

    This primitive provides an anonymous collection of aggregators (unless the integer index is taken to have special meaning, but generally such bookkeeping should be encoded in strings). Indexes can be nested to create two-dimensional ordinal grids of aggregators. (Use org.dianahep.histogrammar.Bin if the space is to have a metric interpretation.)

    Note that all sub-aggregators within an Index must have the same type (e.g. histograms of different binnings, but all histograms). To collect objects of different types, still indexed by integer, use org.dianahep.histogrammar.Branch.

    To collect aggregators of the same type with string-based labels, use org.dianahep.histogrammar.Label. To collect aggregators of different types with string-based labels, use org.dianahep.histogrammar.UntypedLabel.

    Factory produces mutable org.dianahep.histogrammar.Indexing and immutable org.dianahep.histogrammar.Indexed objects.

92.  object IntegerIndex
93.  object IrregularlyBin extends Factory

    Accumulate a suite of aggregators, each between two thresholds, filling exactly one per datum.

    Accumulate a suite of aggregators, each between two thresholds, filling exactly one per datum.

    This is a variation on org.dianahep.histogrammar.Stack, which fills N + 1 aggregators with N successively tighter cut thresholds. IrregularlyBin fills N + 1 aggregators in the non-overlapping intervals between N thresholds.

    IrregularlyBin is also similar to org.dianahep.histogrammar.CentrallyBin, in that they both partition a space into irregular subdomains with no gaps and no overlaps. However, CentrallyBin is defined by bin centers and IrregularlyBin is defined by bin edges, the first and last of which are at negative and positive infinity.

    Factory produces mutable org.dianahep.histogrammar.IrregularlyBinning and immutable org.dianahep.histogrammar.IrregularlyBinned objects.

94.  object Label extends Factory

    Accumulate any number of aggregators of the same type and label them with strings.

    Accumulate any number of aggregators of the same type and label them with strings. Every sub-aggregator is filled with every input datum.

    This primitive simulates a directory of aggregators. For sub-directories, nest collections within the Label collection.

    Note that all sub-aggregators within a Label must have the same type (e.g. histograms of different binnings, but all histograms). To collect objects of different types with string-based look-up keys, use org.dianahep.histogrammar.UntypedLabel.

    To collect aggregators of the same type without naming them, use org.dianahep.histogrammar.Index. To collect aggregators of different types without naming them, use org.dianahep.histogrammar.Branch.

    In strongly typed languages, the restriction to a single type allows nested objects to be extracted without casting.

    Factory produces mutable org.dianahep.histogrammar.Labeling and immutable org.dianahep.histogrammar.Labeled objects.

95.  object Maximize extends Factory

    Find the maximum value of a given quantity.

    Find the maximum value of a given quantity. If no data are observed, the result is NaN.

    Factory produces mutable org.dianahep.histogrammar.Maximizing and immutable org.dianahep.histogrammar.Maximized objects.

96.  object Minimize extends Factory

    Find the minimum value of a given quantity.

    Find the minimum value of a given quantity. If no data are observed, the result is NaN.

    Factory produces mutable org.dianahep.histogrammar.Minimizing and immutable org.dianahep.histogrammar.Minimized objects.

97.  object Select extends Factory

    Filter or weight data according to a given selection.

    Filter or weight data according to a given selection.

    This primitive is a basic building block, intended to be used in conjunction with anything that needs a user-defined cut. In particular, a standard histogram often has a custom selection, and this can be built by nesting Select -> Bin -> Count.

    Select also resembles org.dianahep.histogrammar.Fraction, but without the denominator.

    The efficiency of a cut in a Select aggregator named x is simply x.cut.entries / x.entries (because all aggregators have an entries member).

    Factory produces mutable org.dianahep.histogrammar.Selecting and immutable org.dianahep.histogrammar.Selected (sic) objects.

98.  object SparselyBin extends Factory

    Split a quantity into equally spaced bins, creating them whenever their entries would be non-zero.

    Split a quantity into equally spaced bins, creating them whenever their entries would be non-zero. Exactly one sub-aggregator is filled per datum.

    Use this when you have a distribution of known scale (bin width) but unknown domain (lowest and highest bin index).

    Unlike fixed-domain binning, this aggregator has the potential to use unlimited memory. A large number of distinct outliers can generate many unwanted bins.

    Like fixed-domain binning, the bins are indexed by integers, though they are 64-bit and may be negative. Bin indexes below -(2**63 - 1) are put in the -(2**63 - 1) are bin and indexes above (2**63 - 1) are put in the (2**63 - 1) bin.

    Factory produces mutable org.dianahep.histogrammar.SparselyBinning and immutable org.dianahep.histogrammar.SparselyBinned objects.

99.  object Stack extends Factory

    Accumulates a suite of aggregators, each filtered with a tighter selection on the same quantity.

    Accumulates a suite of aggregators, each filtered with a tighter selection on the same quantity.

    This is a generalization of org.dianahep.histogrammar.Fraction, which fills two aggregators, one with a cut, the other without. Stack fills N + 1 aggregators with N successively tighter cut thresholds. The first is always filled (like the denominator of Fraction), the second is filled if the computed quantity exceeds its threshold, the next is filled if the computed quantity exceeds a higher threshold, and so on.

    The thresholds are presented in increasing order and the computed value must be greater than or equal to a threshold to fill the corresponding bin, and therefore the number of entries in each filled bin is greatest in the first and least in the last.

    Although this aggregation could be visualized as a stack of histograms, stacked histograms usually represent a different thing: data from different sources, rather than different cuts on the same source. For example, it is common to stack Monte Carlo samples from different backgrounds to show that they add up to the observed data. The Stack aggregator does not make plots of this type because aggregation trees in Histogrammar draw data from exactly one source.

    To make plots from different sources in Histogrammar, one must perform separate aggregation runs. It may then be convenient to stack the results of those runs as though they were created with a Stack aggregation, so that plotting code can treat both cases uniformly. For this reason, Stack has an alternate constructor to build a Stack manually from distinct aggregators, even if those aggregators came from different aggregation runs.

    Factory produces mutable org.dianahep.histogrammar.Stacking and immutable org.dianahep.histogrammar.Stacked objects.

100.  object StringIndex
101.  object Sum extends Factory

     Accumulate the (weighted) sum of a given quantity, calculated from the data.

     Accumulate the (weighted) sum of a given quantity, calculated from the data.

     Sum differs from org.dianahep.histogrammar.Count in that it computes a quantity on the spot, rather than percolating a product of weight metadata from nested primitives. Also unlike weights, the sum can add both positive and negative quantities (weights are always non-negative).

     Factory produces mutable org.dianahep.histogrammar.Summing and immutable org.dianahep.histogrammar.Summed objects.

102.  object SymbolIndex
103.  object UntypedLabel extends Factory

     Accumulate any number of aggregators of any type and label them with strings.

     Accumulate any number of aggregators of any type and label them with strings. Every sub-aggregator is filled with every input datum.

     This primitive simulates a directory of aggregators. For sub-directories, nest collections within the UntypedLabel.

     Note that sub-aggregators within an UntypedLabel may have different types. In strongly typed languages, this flexibility poses a problem: nested objects must be type-cast before they can be used. To collect objects of the same type with string-based look-up keys, use org.dianahep.histogrammar.Label.

     To collect aggregators of the same type without naming them, use org.dianahep.histogrammar.Index. To collect aggregators of different types without naming them, use org.dianahep.histogrammar.Branch.

     Factory produces mutable org.dianahep.histogrammar.UntypedLabeling and immutable org.dianahep.histogrammar.UntypedLabeled objects.

     Note: the compiler cannot predict the type of data that is drawn from this collection, so it must be cast with as.

104.  object Version