histogrammar

Value Members

1. 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.

2. 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.

3. 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.

4. 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, ...).

5. object BranchedNil extends BranchedList with Serializable

   

6. object BranchingNil extends BranchingList with Serializable

   

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

8. 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.

9. 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.

10. 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.

11. 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.

12. 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.

13. 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.

14. 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.

15. object IntegerIndex

    

16. 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.

17. 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.

18. 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.

19. 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.

20. 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.

21. 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.

22. 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.

23. 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.

24. 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.

25. 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.

26. 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.

27. 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.

28. object StringIndex

    

29. 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.

30. object SymbolIndex

    

31. 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.

32. 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.

33. 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.

34. object Version

    

35. 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

    

36. 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

    

37. 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

    

38. 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

    

39. 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

    

40. 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

    

41. 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

    

42. 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

    

43. 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

    

44. 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

    

45. 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

    

46. 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

    

47. 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

    

48. 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

    

49. 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

    

50. 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

    

51. 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

    

52. 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

    

53. 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

    

54. 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

    

55. 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

    

56. implicit def anySelectedSparselyBinnedToFractionedHistogramMethods[N <: Container[N] with NoAggregation](hist: Fractioned[Selected[SparselyBinned[Counted, N]], Selected[SparselyBinned[Counted, N]]]): FractionedHistogramMethods

    

57. implicit def anySelectedSparselyBinnedToHistogramMethods[N <: Container[N] with NoAggregation](hist: Selected[SparselyBinned[Counted, N]]): HistogramMethods

    

58. implicit def anySelectedSparselyBinnedToPartitionedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: IrregularlyBinned[Selected[SparselyBinned[Counted, N]], SN]): PartitionedHistogramMethods

    

59. implicit def anySelectedSparselyBinnedToProfileErrMethods[N <: Container[N] with NoAggregation](hist: Selected[SparselyBinned[Deviated, N]]): ProfileErrMethods

    

60. implicit def anySelectedSparselyBinnedToProfileMethods[N <: Container[N] with NoAggregation](hist: Selected[SparselyBinned[Averaged, N]]): ProfileMethods

    

61. implicit def anySelectedSparselyBinnedToStackedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: Stacked[Selected[SparselyBinned[Counted, N]], SN]): StackedHistogramMethods

    

62. 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

    

63. 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

    

64. 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

    

65. 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

    

66. 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

    

67. 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

    

68. implicit def anySelectingSparselyBinningToFractionedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Fractioning[DATUM, Selecting[DATUM, SparselyBinning[DATUM, Counting, N]]]): FractionedHistogramMethods

    

69. implicit def anySelectingSparselyBinningToHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, SparselyBinning[DATUM, Counting, N]]): HistogramMethods

    

70. 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

    

71. implicit def anySelectingSparselyBinningToProfileErrMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, SparselyBinning[DATUM, Deviating[DATUM], N]]): ProfileErrMethods

    

72. implicit def anySelectingSparselyBinningToProfileMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Selecting[DATUM, SparselyBinning[DATUM, Averaging[DATUM], N]]): ProfileMethods

    

73. 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

    

74. 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

    

75. implicit def anySparselyBinnedToFractionedHistogramMethods[N <: Container[N] with NoAggregation](hist: Fractioned[SparselyBinned[Counted, N], SparselyBinned[Counted, N]]): FractionedHistogramMethods

    

76. implicit def anySparselyBinnedToHistogramMethods[N <: Container[N] with NoAggregation](hist: SparselyBinned[Counted, N]): HistogramMethods

    

77. implicit def anySparselyBinnedToPartitionedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: IrregularlyBinned[SparselyBinned[Counted, N], SN]): PartitionedHistogramMethods

    

78. implicit def anySparselyBinnedToProfileErrMethods[N <: Container[N] with NoAggregation](hist: SparselyBinned[Deviated, N]): ProfileErrMethods

    

79. implicit def anySparselyBinnedToProfileMethods[N <: Container[N] with NoAggregation](hist: SparselyBinned[Averaged, N]): ProfileMethods

    

80. implicit def anySparselyBinnedToStackedHistogramMethods[N <: Container[N] with NoAggregation, SN <: Container[SN] with NoAggregation](hist: Stacked[SparselyBinned[Counted, N], SN]): StackedHistogramMethods

    

81. implicit def anySparselyBinningToFractionedHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: Fractioning[DATUM, SparselyBinning[DATUM, Counting, N]]): FractionedHistogramMethods

    

82. implicit def anySparselyBinningToHistogramMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: SparselyBinning[DATUM, Counting, N]): HistogramMethods

    

83. 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

    

84. implicit def anySparselyBinningToProfileErrMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: SparselyBinning[DATUM, Deviating[DATUM], N]): ProfileErrMethods

    

85. implicit def anySparselyBinningToProfileMethods[DATUM, N <: Container[N] with Aggregation { type Datum >: DATUM }](hist: SparselyBinning[DATUM, Averaging[DATUM], N]): ProfileMethods

    

86. 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

    

87. package ascii

    

    Methods for drawing familiar combinations of containers, such as histograms, in ASCII art.

88. 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

    

89. 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

    

90. implicit def branchedToCollectionMethods(branched: Branched[_, _]): CollectionMethods

    

91. implicit def branchingToCollectionMethods(branching: Branching[_, _]): CollectionMethods

    

92. def help: String

    

    Help function for interactive use.

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

93. implicit def indexedToCollectionMethods(indexed: Indexed[_]): CollectionMethods

    

94. implicit def indexingToCollectionMethods(indexing: Indexing[_]): CollectionMethods

    

95. package json

    

    Provides support for parsing and stringifying JSON.

    Provides support for parsing and stringifying JSON.

    This module is a new implementation; it does not depend on packages such as Jackson. This choice was to provide the following features:

    • fewer dependencies, to make it easier to embed Histogrammar
    • concise pattern-matching in org.dianahep.histogrammar.Container fromJsonFragment methods
    • special handling of "-inf", "inf", "nan" as numbers, rather than strings
    • partial parsing failures return None, rather than raising exceptions.

96. implicit def labeledToCollectionMethods(labeled: Labeled[_]): CollectionMethods

    

97. implicit def labelingToCollectionMethods(labeling: Labeling[_]): CollectionMethods

    

98. 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

    

99. implicit def selectedSparselyBinnedToTwoDimensionallyHistogramMethods[NX <: Container[NX] with NoAggregation, NY <: Container[NY] with NoAggregation](hist: Selected[SparselyBinned[SparselyBinned[Counted, NY], NX]]): TwoDimensionallyHistogramMethods

    

100. 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

     

101. 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

     

102. implicit def sparselyBinnedToTwoDimensionallyHistogramMethods[NX <: Container[NX] with NoAggregation, NY <: Container[NY] with NoAggregation](hist: SparselyBinned[SparselyBinned[Counted, NY], NX]): TwoDimensionallyHistogramMethods

     

103. 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

     

104. implicit def untypedLabeledToCollectionMethods(untypedLabeled: UntypedLabeled): CollectionMethods

     

105. implicit def untypedLabelingToCollectionMethods(untypedLabeling: UntypedLabeling[_]): CollectionMethods

     

106. def unweighted[DATUM]: Unweighted[DATUM]

     

     Default weighting function that always returns 1.0.

107. package util

     

     Supporting functions, mostly called by those in org.dianahep.histogrammar.