YODA TODO list
==============

1.4.0
-----

* Python access to Counter, Scatter1D, and Scatter3D

* YODA persistence to read Scatter1D and Counter

* Add a goodness of fit test collection (AB)
   Simple GoF measures, such as chi2 of a bin and of a histo (chained), for 1D
   and 2D Histos, Profiles and Scatters. Also KS (later)?

* Add an inverse transform sampling function.
   Via Scatter objects with manually computed integral histo? 2D histo and
   profile don't have integral/CDF methods.

* 2D histogram outflow improvements
   Store full sets of outflow bins corresponding to an extended grid, and
   provide neat access to them.

* Add 2D histogram conversion to Python layer and yoda2root
   Also Python binding for the H1,P1 -> TGraph routines.


LATER
-----

* Python docstrings for Points, Dbns and Bins (AB)

* Consider C++ alternative data handling programs, maybe in contrib?

* Add Axis2D -> Histo2D/Profile2D bin adding and erasing. (AB)
   Adding 2D operator support and bin-adding/erasing

* Histo/Profile2D marginalisation down to x and y Histo/Profile1D
   Requires full detail outflows (and optional args to use them or not)

* 2D binning rectangular bin merges

* 2D binning integer bin merges
   Only rebin perfect grids: need to detect them. Global rebinning of Axis2D ->
   Histo2D by generally different integer factors in x and y directions.

* Add pytest-p1d and pytest-s{1,2,3}d



2.0.0
-----

* "Infinite binning" scheme
   Rewrite of internals to base all binning on N+2 bin lookup, where each axis
   has an underflow and overflow to infinity as fully fledged bins. This binning
   is to be generically templated for 1 and 2 dims and exposed in the API, to
   allow BinnedValue1D,2D and completely arbitrary types as well as fillable
   histograms.

   Official types will use Binning1D,2D internally. Binned1D,2D base types to be
   introduced, to reduce duplication of bin-edge etc. method
   declarations. Direct bin access and fill methods, plus specialist features,
   need to be re-implemented... and maybe use multiple inheritance to provide
   common functions like Profile and Histo 'dimensionless' functionality.

   Now return underflow and overflow as (const) Bins rather than Dbns, or
   continue accessing via Dbns? I like the uniformity of everything being a
   Bin, and the bin edges are not invalid, just not very helpful.

* ROOT Reader/Writer

* Versioning in the YODA format headers

* Add support for multiple errors on scatters

* Re-order scatter errors as x y ex+- ey+- (ex+- ey+- ...) in YODA format
   This way makes most sense for multiple errors on scatters.

* Add Scatter3D/Point3D and conversion/division/efficiency from Profile2D(s)

* Add Scatter1D/Point1D and conversion/division/efficiency from Counter(s)

* Add copy assignment to both C++ and Cython (AB)

* Add stdErr to HistoBinXD (AB)

* Use better error than sqrt(sumW2()) in HistoBin
   Actually implement on Dbn0D? Should we have better separation of pure-w and wx**n?

* Test negative- and mixed-weighted stat calculations, and scaling.

* Rename/alias Axis as Binning
   This is just a better name for what it does. Expose it for use with arbitrary
   contained types: doubles and Histos. Bin by string value (or arbitrary
   types... again?) Separate "bin-lookup" types with and without overflow
   capability?


2.1.0
-----

* Automatic dynamic rebinning by sequential bin merging
   Like a jet algorithm: define a stat poorness measure and stopping
   condition... user-suppliable as function objects? After writing a YODA paper,
   maybe write this up: some work already done but not in YODA.


AND THEN...
-----------

* Remove non-const bin access from Histos and Profiles?
   cf. David D's point re. consistency via email on 7/8/2012
   In practice they can't be removed as they are used internally. Attempting to
   make them protected/private didn't work due to requirements of the Python
   wrapper code... leaving it as-is for now.

* Test gap handling on 1D and 2D axes.

* Add Histo2D binning constructors from Scatter3D and Profile2D.


AND AFTER THAT...

* Integer axis

* Allow comments on ends of YODA format data lines in ReaderYODA (HH)
   Ignore anything after "#" on data lines -- use this to write convenience
   height & error info for each bin since not obvious from sumWX2 etc.

* Multi-error support on Point types
   Access by index, with negative (enum) indices for quad/linear/largest combn?

* Scatter2D -> Scatter<N> again (?) with specialisations for 1D, 2D and 3D

* Terminal histos via WriterAsciiArt

* Write scripts to convert between data formats and to plot results.

* Template all classes on floating point type (default to double)

* Look into pickling of C++ interfaced classes. WriterS10n? MessagePack? Protobuf?

* Simple ntupling, done well :-)
   Surprisingly the Protobuf, MsgPack, etc. systems don't seem designed for
   ntuples... surely something is? Maybe wrap HDF5 or similar? Not to be
   embarked upon lightly: we'd need to be certain that we could make something
   really nice.
