{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get started with physt\n",
    "\n",
    "This tutorial describes some of the basic features of physt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Necessary import evil\n",
    "%matplotlib inline\n",
    "from physt import histogram, binnings, h1, h2, h3\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(1337)     # Have always the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting physt (to run)\n",
    "\n",
    "I believe you can skip this section but anyway, for the sake of completeness, the default way of installing a relatively stable version of physt is via pip:\n",
    "\n",
    "`pip install physt`\n",
    "\n",
    "Alternatively, you can download the source code from github (https://github.com/janpipek/physt).\n",
    "\n",
    "You will need **numpy** to use physt (required), but there are other packages (optional) that are very useful if you want to use physt at its best: **matplotlib** for plotting (or **bokeh** as a not-so-well supported alternative)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your first histogram\n",
    "\n",
    "If you need to create a histogram, call the `histogram` (or `h1`) function with your data (like heights of people) as the first argument. The default gives a reasonable result..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(10,), total=56, dtype=int64)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Basic dataset\n",
    "heights = [160, 155, 156, 198, 177, 168, 191, 183, 184, 179, 178, 172, 173, 175,\n",
    "           172, 177, 176, 175, 174, 173, 174, 175, 177, 169, 168, 164, 175, 188,\n",
    "           178, 174, 173, 181, 185, 166, 162, 163, 171, 165, 180, 189, 166, 163,\n",
    "           172, 173, 174, 183, 184, 161, 162, 168, 169, 174, 176, 170, 169, 165]\n",
    "\n",
    "hist = histogram(heights)     # Automatically select all settings\n",
    "hist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...which is an object of the Histogram1D type that holds all the bin information..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[155. , 159.3],\n",
       "       [159.3, 163.6],\n",
       "       [163.6, 167.9],\n",
       "       [167.9, 172.2],\n",
       "       [172.2, 176.5],\n",
       "       [176.5, 180.8],\n",
       "       [180.8, 185.1],\n",
       "       [185.1, 189.4],\n",
       "       [189.4, 193.7],\n",
       "       [193.7, 198. ]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.bins          # All the bins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  6,  5, 11, 15,  7,  6,  2,  1,  1])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.frequencies   # All the frequencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...and provides further features and methods, like plotting for example..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe2810aac88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot(show_values=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...or adding new values (note that this is something numpy.histogram won't do for you)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(10,), total=64, dtype=int64)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe27ac7b908>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "original = hist.copy()             # Store the original data to see changes\n",
    "\n",
    "# ******* Here comes a lonely giant\n",
    "hist.fill(197)                     \n",
    "\n",
    "step1 = hist.copy()                # Store the intermediate value\n",
    "\n",
    "# ******* And a bunch of relatively short people\n",
    "hist.fill_n([160, 160, 161, 157, 156, 159, 162])\n",
    "\n",
    "# See how the plot changes (you can safely ignore the following 4 lines)\n",
    "ax = hist.plot(label=\"After fill_n\");                  \n",
    "step1.plot(color=\"yellow\", ax=ax, label=\"After fill\")\n",
    "original.plot(color=\"red\", ax=ax, label=\"Before filling\")\n",
    "ax.legend(loc=1)\n",
    "\n",
    "# See the number of entries \n",
    "hist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data representation\n",
    "\n",
    "The primary goal of physt library is to represent histograms as data objects with a set methods for easy manipulation and analysis (including mathematical operations, adaptivity, summary statistics. ...). The histogram classes used in [ROOT](https://root.cern.ch/) framework served as inspiration but not as a model to copy (though relevant methods often have same names).\n",
    "\n",
    "Based on its dimensionality, a histogram is an instance of one of the following classes (all inheriting from **HistogramBase**):\n",
    "\n",
    "* **Histogram1D** for univariate data\n",
    "* **Histogram2D** for bivariate data\n",
    "* **HistogramND** for data with higher dimensionality\n",
    "* ...or some special dedicated class (user-provided). Currently, there is a **PolarHistogram** as an example (considered to be experimental, not API-stable).\n",
    "\n",
    "However, these objects are \\__init\\__ialized with already calculated data and therefore, you typically don't construct the yourselves but call one of the facade functions:\n",
    "\n",
    "* **histogram** or **h1**\n",
    "* **histogram2d** or **h2**\n",
    "* **histogramdd** (or **h3** for 3D case)\n",
    "\n",
    "These functions try to find the best binning schema, calculate bin contents and set other properties for the histograms. In principle (if not, submit a bug report), if you call a function with arguments understood by eponymous numpy functions ([histogram](http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.histogram.html), [histogram2d](http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.histogram2d.html) and [histogramdd](http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.histogramdd.html)), you should receive histogram with exactly the same bin edges and bin contents. However, there are many more arguments available!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Back to people's parameters...\n",
    "heights = np.random.normal(172, 10, 100)\n",
    "weights = np.random.normal(70, 15, 100)\n",
    "iqs = np.random.normal(100, 15, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(10,), total=100, dtype=int64)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1D histogram\n",
    "h1(heights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram2D(bins=(5, 7), total=100, dtype=int64)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2D histogram\n",
    "h2(heights, weights, [5, 7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HistogramND(bins=(10, 10, 10), total=100, dtype=int64)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3D histogram\n",
    "h3([heights, weights, iqs])      # Simplification with respect to numpy.histogramdd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, what do these objects contain? In principle:\n",
    "\n",
    "- binning schema (`_binning` or `_binnings`)\n",
    "- bin contents (`frequencies`) together with errors (`errors`)\n",
    "- some statistics about the data (`mean`, `variance`, `std`)\n",
    "- metadata (like `name` and `axis_name` or `axis_names`)\n",
    "- ...\n",
    "\n",
    "In the following, properties of `Histogram1D` will be described. Analogous methods and data fields do exist also for `Histogram2D` and `HistogramND`, perhaps with the name in plural."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binning schema\n",
    "\n",
    "The structure of bins is stored in the histogram object as a hidden attribute `_binning`. This value is an instance of one of the binning classes that are all descendants of `physt.binnings.BinningBase`. You are not supposed to directly access this value because manipulating it without at the same time updating the bin contents is dangerous.\n",
    "\n",
    "A dedicated notebook deals with the binning specifics, here we sum at least the most important features.\n",
    "\n",
    "`Histogram1D` offers the following attributes to access (read-only or read-only-intended) the binning information (explicitly or implicitly stored in `_binning`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(6,), total=10000, dtype=int64)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a histogram with \"reasonable\" bins\n",
    "data = np.random.normal(0, 7, 10000)\n",
    "hist = histogram(data, \"human\", 4)\n",
    "hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FixedWidthBinning(bin_width=10.0, bin_count=6, min=-30.0)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist._binning         # Just to show, don't use it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.bin_count        # The total number of bins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-30., -20.],\n",
       "       [-20., -10.],\n",
       "       [-10.,   0.],\n",
       "       [  0.,  10.],\n",
       "       [ 10.,  20.],\n",
       "       [ 20.,  30.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.bins             # Bins as array of both edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-30., -20., -10.,   0.,  10.,  20.,  30.])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.numpy_bins       # Bin edges with the same semantics as the numpy.histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-30., -20., -10.,   0.,  10.,  20.])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.bin_left_edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-20., -10.,   0.,  10.,  20.,  30.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.bin_right_edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-25., -15.,  -5.,   5.,  15.,  25.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.bin_centers      # Centers of the bins - useful for interpretation of histograms as scatter data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10., 10., 10., 10., 10., 10.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.bin_widths       # Widths of the bins - useful for calculating densities and also for bar plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as a simple overview of binning schemas, that are provided by physt, we show the bins as produced by different schemas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['numpy',\n",
       " 'exponential',\n",
       " 'quantile',\n",
       " 'fixed_width',\n",
       " 'integer',\n",
       " 'human',\n",
       " 'blocks',\n",
       " 'knuth',\n",
       " 'scott',\n",
       " 'freedman']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(binnings.binning_methods.keys())        # Show them all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These names can be used as the second parameter of the `h1` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-30., -24., -18., -12.,  -6.,   0.,   6.,  12.,  18.,  24.,  30.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fixed-width\n",
    "h1(data, \"fixed_width\", 6).numpy_bins  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected: [-26.89092563 -16.07128189  -5.25163815   5.56800559  16.38764933\n",
      "  27.20729307]\n",
      "We got: [-26.89092563 -16.07128189  -5.25163815   5.56800559  16.38764933\n",
      "  27.20729307]\n"
     ]
    }
   ],
   "source": [
    "# Numpy-like\n",
    "print(\"Expected:\", np.histogram(data, 5)[1])\n",
    "\n",
    "print(\"We got:\", h1(data, \"numpy\", 5).numpy_bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-27.5, -26.5, -25.5, -24.5, -23.5, -22.5, -21.5, -20.5, -19.5,\n",
       "       -18.5, -17.5, -16.5, -15.5, -14.5, -13.5, -12.5, -11.5, -10.5,\n",
       "        -9.5,  -8.5,  -7.5,  -6.5,  -5.5,  -4.5,  -3.5,  -2.5,  -1.5,\n",
       "        -0.5,   0.5,   1.5,   2.5,   3.5,   4.5,   5.5,   6.5,   7.5,\n",
       "         8.5,   9.5,  10.5,  11.5,  12.5,  13.5,  14.5,  15.5,  16.5,\n",
       "        17.5,  18.5,  19.5,  20.5,  21.5,  22.5,  23.5,  24.5,  25.5,\n",
       "        26.5,  27.5])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integer - centered around integers; useful for integer data\n",
    "h1(data, \"integer\").numpy_bins     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.03182494e-03, 2.03397046e-03, 4.00943579e-03, 7.90354415e-03,\n",
       "       1.55797507e-02, 3.07113654e-02, 6.05393490e-02, 1.19337344e-01,\n",
       "       2.35242068e-01, 4.63717632e-01, 9.14096888e-01, 1.80190069e+00,\n",
       "       3.55197150e+00, 7.00177407e+00, 1.38021491e+01, 2.72072931e+01])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exponential - positive numbers required\n",
    "h1(np.abs(data), \"exponential\").numpy_bins      # We 'abs' the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-26.89092563,  -5.87687499,  -1.69550961,   1.81670859,\n",
       "         5.79232538,  27.20729307])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Quantile - each bin should have a similar statistical importance\n",
    "h1(data, \"quantile\", 5).numpy_bins\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-30., -25., -20., -15., -10.,  -5.,   0.,   5.,  10.,  15.,  20.,\n",
       "        25.,  30.])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Human - as friendly to your plots as possible, you may set an approximate number of bins\n",
    "h1(data, \"human\").numpy_bins             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bin contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bin contents (`frequencies`) and associated errors (`errors`) are stored as numpy arrays with a shape corresponding to number of bins (in all dimensions). Again, you cannot manipulate these properties diractly (unless you break the dont-touch-the-underscore convention)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   2,   23,  140,  604, 1580, 2601, 2691, 1640,  573,  124,   17,\n",
       "          5])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist = h1(data, \"human\")\n",
    "\n",
    "hist.frequencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Errors are calculated as $\\sqrt(N)$ which is the simplest expectation for independent values. If you don't accept this, you can set your errors through `_errors2` field which contains squared errors.\n",
    "\n",
    "Note: Filling with weights, arithmetic operations and scaling preserve correct error values under similar conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.41421356,  4.79583152, 11.83215957, 24.57641145, 39.74921383,\n",
       "       51.        , 51.8748494 , 40.49691346, 23.93741841, 11.13552873,\n",
       "        4.12310563,  2.23606798])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  2.82842712,   9.59166305,  23.66431913,  49.15282291,\n",
       "        79.49842766, 102.        , 103.74969879,  80.99382693,\n",
       "        47.87483681,  22.27105745,   8.24621125,   4.47213595])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Doubling the histogram doubles the error\n",
    "(hist * 2).errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data types\n",
    "\n",
    "Internally, histogram bins can contain values in several types (`dtype` in numpy terminology). By default, this is either `np.int64` (for histograms without weights) or `np.float64` (for histograms with weight). Wherever possible, this distinction is preserved. If you try filling in with weights, if you multiply by a float constant, if you divide, ... - basically whenever this is reasonable - an integer histogram is automatically converted to a float one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default type: int64\n",
      "Default type with weights: float64\n",
      "Default type after filling with weight: float64\n",
      "Default type after multiplying by an int: int64\n",
      "Default type after multiplying by a float: float64\n"
     ]
    }
   ],
   "source": [
    "hist = h1(data)\n",
    "print(\"Default type:\", hist.dtype)\n",
    "\n",
    "hist = h1(data, weights=np.abs(data))    # Add some random weights\n",
    "print(\"Default type with weights:\", hist.dtype)\n",
    "\n",
    "hist = h1(data)\n",
    "hist.fill(1.0, weight=.44)\n",
    "print(\"Default type after filling with weight:\", hist.dtype)\n",
    "\n",
    "hist = h1(data)\n",
    "hist *= 2\n",
    "print(\"Default type after multiplying by an int:\", hist.dtype)\n",
    "\n",
    "hist *= 5.6\n",
    "print(\"Default type after multiplying by a float:\", hist.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can specify the type in the method call\n",
    "hist = h1(data, dtype=\"int32\")\n",
    "hist.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can set the type of the histogram using the attribute\n",
    "hist = h1(data)\n",
    "hist.dtype = np.int32\n",
    "hist.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Adding two histograms uses the broader range\n",
    "hist1 = h1(data, dtype=\"int64\")\n",
    "hist2 = h1(data, dtype=\"float32\")\n",
    "(hist1 + hist2).dtype    # See the result!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manually create histogram instances\n",
    "\n",
    "As mentioned, `h1` and `h2` are just facade functions. You can construct the objects directly using the constructors. The first argument accepts something that can be interpreted as binning or list of bins, second argument is an array of frequencies (numpy array or something convertible)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Histogram1D(bins=(5,), total=15, dtype=int64),\n",
       " Histogram2D(bins=(2, 3), total=23.7, dtype=float64))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe2a94775f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from physt.histogram1d import Histogram1D\n",
    "from physt.histogram_nd import Histogram2D\n",
    "hist1 = Histogram1D([0.0, 0.2, 0.4, 0.6, 0.8, 1.0], [1, 2, 3, 4, 5])\n",
    "hist2 = Histogram2D([[0, 0.5, 1], [0, 1, 2, 3]], [[0.2, 2.2, 7.3], [6, 5, 3]], axis_names=[\"x\", \"y\"])\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
    "hist1.plot(ax = axes[0])\n",
    "hist2.plot(ax = axes[1])\n",
    "hist1, hist2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(9,), total=97.8, dtype=float64)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe2799590b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a physt \"logo\", also available as physt.examples.fist\n",
    "_, ax = plt.subplots(figsize=(4, 4))\n",
    "widths = np.cumsum([0, 1.2, 0.2, 1, 0.1, 1, 0.1, 0.9, 0.1, 0.8])\n",
    "fingers = np.asarray([4, 1, 7.5, 6, 7.6, 6, 7.5, 6, 7.2]) + 5\n",
    "hist1 = Histogram1D(widths, fingers)\n",
    "hist1.plot(lw=0, ax=ax)\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "ax.set_xlabel(\"physt\")\n",
    "hist1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supported indexing is more or less compatible with numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.find_bin(3)             # Find a proper bin for some value (0 - based indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-10.66146002,  -5.25163815]), 1600)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist[3]                      # Return the bin (with frequency)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(3,), total=559, dtype=int32)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist[-3:]                    # Sub-histogram (as slice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(10,), total=10000, dtype=int32)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist[hist.frequencies > 5]   # Masked array (destroys underflow & overflow information)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(3,), total=4550, dtype=int32)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist[[1, 3, 5]]              # Select some of the bins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistics\n",
    "\n",
    "When creating histograms, it is possible to keep simple statistics about the sampled distribution,\n",
    "like mean() and std(). The behaviour was inspired by similar features in ROOT.\n",
    "\n",
    "**To be yet refined.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.007186746661025421"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.957365686383901"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting\n",
    "\n",
    "This is currently based on matplotlib, but other tools might come later (d3.js, bokeh?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe27abfe780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot();     # Basic plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe2798a5860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot(density=True, errors=True, ecolor=\"red\");   # Include errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe279814160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot(show_stats=True, errors=True, alpha=0.3);    # Show summary statistics (not fully supported yet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe27973e6d8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot(cumulative=True, color=\"yellow\", lw=3, edgecolor=\"red\");           # Use matplotlib parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe279775400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot(kind=\"scatter\", s=hist.frequencies, cmap=\"rainbow\", density=True);    # Another plot type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fe2796ff860>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe2796eb748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot(kind=\"step\", lw=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fe2796154a8>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAGgNJREFUeJzt3X20XXV95/H3Nw+XEIEEzCWEPDQRQxeIGDADjKCiSAg+gbNgreAImUiN08L4sGwXqKulFal0iTKjQ1mlQ2roQhkUldRSMYItagUSFJEYgYgOhIQkkASBhIQk3/lj79RDch/OfTy/e+/7tdZdZ5/f/u1zvnsnuZ/89v6dfSIzkSSpNKNaXYAkSR0xoCRJRTKgJElFMqAkSUUyoCRJRTKgJElFMqAkSUUyoCRJRTKgJElFGtPqAroyadKknDlzZqvLkCT1owceeOCZzGzvrl/RATVz5kxWrlzZ6jIkSf0oIv5fM/08xSdJKpIBJUkqkgElSSqSASVJKpIBJUkqUrcBFRHjIuL+iPh5RKyKiL+q22dFxH0R8VhE/N+IaKvbD6ifr6nXz2x4rU/W7Y9ExFkDtVOSpKGvmRHUDuDtmfkGYA4wPyJOAf4GuDYzZwNbgIvr/hcDWzLztcC1dT8i4lhgAfA6YD7wtxExuj93RpI0fHQbUFl5oX46tv5J4O3AN+r2pcC59fI59XPq9WdERNTtt2Tmjsz8DbAGOKlf9kKSNOw0dQ0qIkZHxIPARmA58Gtga2buqrusBabWy1OBJwHq9c8Br25s72CbxvdaHBErI2Llpk2ber5HkqRhoamAyszdmTkHmEY16jmmo271Y3SyrrP2fd/rhsycm5lz29u7vROGJGmY6tEsvszcCvwrcAowMSL23ippGrCuXl4LTAeo108ANje2d7CNJEmv0MwsvvaImFgvHwi8A1gN/AA4r+62ELi9Xl5WP6def3dmZt2+oJ7lNwuYDdzfXzsijWQbNsDnPgfnnQfz5lWPV10FTz/d6sqk3mvmZrFTgKX1jLtRwK2Z+Z2I+CVwS0R8FvgZcGPd/0bgHyNiDdXIaQFAZq6KiFuBXwK7gEsyc3f/7o40svz0p/BXfwXf+171/KWXfr/un/8ZrrwSzjwTrrgC5s5tTY1Sb0U1uCnT3Llz07uZSx27+Wb40IeqUOrqn3EEHHggXH89XHTR4NUndSYiHsjMbv/L5J0kpCHoG9+owmn79q7DCar127bBH/8x3Hrr4NQn9QcDSuqBdevgz/8cZs2CiRNhwgSYMQP+9E/ht78dnBqeegoWLqzCqSe2bYNFi+DJJ7vvK5XAgJKasH49vOtdcNRR8PnPV2H03HPwu99Vv/C//GU45hh429vg8ccHtpbrr4fdvbx6u2sXXHdd/9YjDRSvQUndeOQRePObYcuW6hd8V0aNgoMPhrvugje+sf9refllOPxw2Lq1968xYQJs3Ahtbf1Xl9QTXoOS+sGGDfDWt8Izz3QfTgB79lQjqzPOGJiR1F139X70tFfm72f9SSUzoKQufOIT8Oyz3U9E2Nfzz1eTGPrbU09VIdgXu3ZV19Kk0jXzOShpRNq6FW67rbmR07727IF//3d44olqEkUzrl3+aLd9VmyAcXNhTC9q2mvMGLh7I7y4vPu+Hz/z6N6/kdRHjqCkTvzDP1TXlHprz57+n5AwblzfaoJq+3Hj+qceaSAZUFInvva1amp2b+3cCV//ev/VAzBtWt9P8e3ZA9Ond99PajUDSurEs8/2/TX6MtuuI4ceCkce2bfXOGIKHHZY/9QjDSSvQWnEaeZaD0C+DiZM6dt7jRsP1zZxracnTj21ugnszp0937atDU47tX/rkQaKIyipE696Vd9fY9yBfX+Nfc2eDe2HV5MdemL0aJjUXm0vDQUGlNSJE07o24dZx46FOW/ov3r2ioALPwATJjYfUmPGVP0v/EDfJ1lIg8W/qlInjjuu559/apQJJ57Yf/U0OuAAWPwh+IOZVRB2FjqjRlXrZ8yo+jt7T0OJ16CkTowdC3PmwM9+1vPPQo0aVZ1K64/ThJ1pa4MP/NfqLhf33gsPPVSNriKqcMyE178eTjkF2tsHrg5poBhQUhfe8Q749eOwdUvz07sjqmB697sHtra9Jk2q3mv+fHjhBdixoxphHXRQz69TSSXxFJ/UhbY2WPTfYOKhzf2yHz26ulnsokUwfvyAl/cKY8ZUXwEyeXL1aDhpqDOgpG4cdBB8eHF1PamtreOJE21t1SnB44+HD3+4+rySpL7x/1hSE9ra4Oyz4cwz4eGH4cGfw4svVtd5xo+H419fhZNfYSH1HwNK6oExY6qJE3PmtLoSafjzFJ8kqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSN0GVERMj4gfRMTqiFgVER+t2/8yIp6KiAfrn3c2bPPJiFgTEY9ExFkN7fPrtjURcfnA7JIkaTho5maxu4BPZOZPI+Jg4IGIWF6vuzYzr2nsHBHHAguA1wFHAt+PiKPr1dcBZwJrgRURsSwzf9kfOyJJGl66DajMXA+sr5efj4jVwNQuNjkHuCUzdwC/iYg1wEn1ujWZ+ThARNxS9zWgJEn76dE1qIiYCZwA3Fc3XRoRD0XEkojY+xVtU4EnGzZbW7d11r7veyyOiJURsXLTpk09KU+SNIw0HVARcRBwG/CxzPwdcD1wFDCHaoT1hb1dO9g8u2h/ZUPmDZk5NzPntre3N1ueJGmYaeoLCyNiLFU43ZyZ3wTIzA0N6/8e+E79dC0wvWHzacC6ermzdkmSXqGZWXwB3AiszswvNrRPaej2PuDhenkZsCAiDoiIWcBs4H5gBTA7ImZFRBvVRIpl/bMbkqThppkR1KnAhcAvIuLBuu1TwAURMYfqNN1vgQ8DZOaqiLiVavLDLuCSzNwNEBGXAncCo4ElmbmqH/dFkjSMNDOL70d0fP3oji62uQq4qoP2O7raTpKkvbyThCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUgGlCSpSAaUJKlIBpQkqUjdBlRETI+IH0TE6ohYFREfrdsPi4jlEfFY/Xho3R4R8aWIWBMRD0XEiQ2vtbDu/1hELBy43ZIkDXXNjKB2AZ/IzGOAU4BLIuJY4HLgrsycDdxVPwc4G5hd/ywGrocq0IArgJOBk4Ar9oaaJEn76jagMnN9Zv60Xn4eWA1MBc4BltbdlgLn1svnADdl5V5gYkRMAc4Clmfm5szcAiwH5vfr3kiSho0eXYOKiJnACcB9wOTMXA9ViAGH192mAk82bLa2buusfd/3WBwRKyNi5aZNm3pSniRpGGk6oCLiIOA24GOZ+buuunbQll20v7Ih84bMnJuZc9vb25stT5I0zDQVUBExliqcbs7Mb9bNG+pTd9SPG+v2tcD0hs2nAeu6aJckaT/NzOIL4EZgdWZ+sWHVMmDvTLyFwO0N7RfVs/lOAZ6rTwHeCcyLiEPryRHz6jZJkvYzpok+pwIXAr+IiAfrtk8BVwO3RsTFwBPA+fW6O4B3AmuAbcAigMzcHBFXAivqfp/JzM39sheSpGGn24DKzB/R8fUjgDM66J/AJZ281hJgSU8KlCSNTN5JQpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVKRuv/JdaqVHH4XvfAc2b4aDD4YzzoC5c1tdlaTBYECpSCtWwEc+Aj//OezeDTt3wpgx8JnPwIwZcM018K53tbpKSQPJU3wqzne/C6efDvfeC9u3V+EEsGsXbNsGv/oVnH8+XHddS8uUNMAMKBXl17+G886rgqgr27fDn/0Z3H334NQlafAZUCrKNdfAjh3N9d2+Hf7iLwa2HvWPPXsgs9VVaKgxoFSMF1+Em26qTuU164EHqlGXyrNpE/z1X8OUKTB2bHUNcfp0+MIXYMuWVlenocCAUjF+9avql1hPjB0L9903MPWo926/HWbOhM9+Fp5+uhpB7dkDa9dWo94ZM2D58lZXqdI5i08D6trljzbd98kn4cD/BPFS86/f1gbfXQsb/GVXjDvvhAsuqE7BdmTv9cVzz636nnba4NWmocURlIoxfnw1pbwnIqrtVIbdu+HCCzsPp0bbtsEHPuC1KXXOgFIxXv1qOOignm2TCa95zcDUo5674w54qQcj4GeegR/+cODq0dBmQKkop55aXVdqxujRMGdO8/018G68EZ5/vvn+27bBV74yYOVoiDOgVJQ3vKEaSY0e3XW/CDjwQHjLWwanLjVn/fqe9c+Ep54amFo09HU7SSIilgDvBjZm5nF1218CHwI21d0+lZl31Os+CVwM7AY+kpl31u3zgf8FjAb+T2Ze3b+7ouFgzBhYuBBu+kd49pnf30WiUVsbjBsHixbBq141+DWOJD2Z5ALw0myY0MMR7XMz4NoeTnL5+JlH92wDDUnNzOL7CvC/gZv2ab82M69pbIiIY4EFwOuAI4HvR8Tev0nXAWcCa4EVEbEsM3/Zh9o1TI0bB390MTzyCPzox/D0+mpEtWcPTJhQzfo67jhP7ZXotUfBuqfg5Zeb69/WBkd5DVGd6DagMvOeiJjZ5OudA9ySmTuA30TEGuCket2azHwcICJuqfsaUOrQqFFwzDHVz86d1YX3vSMnlevEE+Hf/q35/plw/PEDV4+Gtr5cg7o0Ih6KiCURcWjdNhV4sqHP2rqts/b9RMTiiFgZESs3bdrUUReNMG1tcMghhtNQMH48zDmhudHt2LFw8snVn6/Ukd4G1PXAUcAcYD3whbo9OuibXbTv35h5Q2bOzcy57e3tvSxPUqucPb+6i0RXITV2LBz9h/D2tw9aWRqCenUniczcsHc5Iv4e+E79dC0wvaHrNGBdvdxZu6RhZNSo6k4S998PP/5xdYq28cO448dX1xHf+MbW1aihoVcBFRFTMnPvhNL3AQ/Xy8uAr0bEF6kmScwG7qcaQc2OiFnAU1QTKd7fl8IllSuiOn138snwxBPVNyIDTJoE06a1tjYNHc1MM/8acDowKSLWAlcAp0fEHKrTdL8FPgyQmasi4laqyQ+7gEsyc3f9OpcCd1JNM1+Smav6fW8kFWfGjOpH6qlmZvFd0EHzjV30vwq4qoP2O4A7elSdJGnE8k4SkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkIhlQkqQiGVCSpCIZUJKkInUbUBGxJCI2RsTDDW2HRcTyiHisfjy0bo+I+FJErImIhyLixIZtFtb9H4uIhQOzO5Kk4aKZEdRXgPn7tF0O3JWZs4G76ucAZwOz65/FwPVQBRpwBXAycBJwxd5QkySpI90GVGbeA2zep/kcYGm9vBQ4t6H9pqzcC0yMiCnAWcDyzNycmVuA5ewfepIk/YfeXoOanJnrAerHw+v2qcCTDf3W1m2dte8nIhZHxMqIWLlp06ZelidJGur6e5JEdNCWXbTv35h5Q2bOzcy57e3t/VqcJGno6G1AbahP3VE/bqzb1wLTG/pNA9Z10S5JUod6G1DLgL0z8RYCtze0X1TP5jsFeK4+BXgnMC8iDq0nR8yr2yRJ6tCY7jpExNeA04FJEbGWajbe1cCtEXEx8ARwft39DuCdwBpgG7AIIDM3R8SVwIq632cyc9+JF5Ik/YduAyozL+hk1Rkd9E3gkk5eZwmwpEfVSZJGLO8kIUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSrSmFYXoHLs2QMPPQQ7dsDxx8OBB7a6IkkjmSMoAfDtb8PUqfDmN8O8eXD44fDZz0JmqyuTNFI5ghLf/z68//2wffsr2z/3Odi9G664ojV1SRrZHEGJyy7bP5wAtm2Dz3++epSkwdangIqI30bELyLiwYhYWbcdFhHLI+Kx+vHQuj0i4ksRsSYiHoqIE/tjB9Q3L78MDz7Y+frRo+GBBwavHknaqz9O8b0tM59peH45cFdmXh0Rl9fPLwPOBmbXPycD19eP6gfXLn+0V9tlwoRTqwkSHTngAPj2Glj5Uh+Kkwq0axe88AIccgiM8lxSkQbij+UcYGm9vBQ4t6H9pqzcC0yMiCkD8P7qgQiYOavz9aNGwZFHDl490kB76SX42Mdg4kSYPBle/Wq48srO/5Om1ulrQCXwvYh4ICIW122TM3M9QP14eN0+FXiyYdu1dZta7Kx50Na2f/vYsTB/vv+71PCRCe95D/zd38GLL8LOnbB1K1x9NfzJn7S6Ou2rr796Ts3ME6lO310SEW/pom900LbfJOaIWBwRKyNi5aZNm/pYnppx+OHwwQ/CrFlVGI0aBZPa4bzzqs9DScPFihXwk59Uo6hG27bB0qWwbl1r6lLH+nQNKjPX1Y8bI+JbwEnAhoiYkpnr61N4G+vua4HpDZtPA/b765CZNwA3AMydO9dP4QySyZPhoouqaeV79lSjJ2m4ufvu6oPoHRk7Fu65BxYsGNya1LleB1REvAoYlZnP18vzgM8Ay4CFwNX14+31JsuASyPiFqrJEc/tPRWocoweXf1IJevtpKAHd1WTgnbt2n/dAQfAvz4D65f3rqaPn3l07zZUp/oygpoMfCsi9r7OVzPzuxGxArg1Ii4GngDOr/vfAbwTWANsAxb14b0lqceOOab6YHpHMuGoowa3HnWt1wGVmY8Db+ig/VngjA7aE7ikt+8nSX11yCHw1rdWp/Jefrlqi4AxY+C9760eVQ7/OCSNKKedBtOmVZMltmyprr++6U0wxQ+9FMeAkjTizJxZ/ahsfsJFklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJANKklQkA0qSVCQDSpJUJAOqRTLh6adh585WVyJJZTKgWmD7djjlFJg5E444Ah5+uNUVSVJ5DKgW+PrXYdUq2LEDtm6Fyy5rdUWSVJ4xrS5gKLp2+aN92v7hZ2H8STBmJ0TAs1Pg2uX9VJykIev222HRIjj4YPinf4Ljj291Ra3lCKoFjj22Or0XAYccAvPmtboiSSVYuBC2bIEnnoBLL211Na3nCKoFRo2CCy6oJkpEtLoaSf2hr2dWAA7+z8Dz1e+Il17bP2dWPn7m0X1/kRZxBNVChpOkRu9/P0ybBq95DbznPa2upvUcQUlSIY44Ai6+uNVVlGPQR1ARMT8iHomINRFx+WC/vySpZ154AX74w+qyxGAa1ICKiNHAdcDZwLHABRFx7EC/70UXQXs7bN480O8kScPPxRfDW94CX/3q4L7vYJ/iOwlYk5mPA0TELcA5wC876vzib57gJxf+jz6/6VtXw+sPglWXwJj+2OOL+l6TJA2G/vgdumAzvOlomHwb/OS7/VBUkyIHccwWEecB8zPzj+rnFwInZ+alDX0WA4vrp38IPDJoBfa/ScAzrS6iMB6Tjnlc9ucx2d9wOSZ/kJnt3XUa7BFUR/PWXpGQmXkDcMPglDOwImJlZs5tdR0l8Zh0zOOyP4/J/kbaMRnsSRJrgekNz6cB6wa5BknSEDDYAbUCmB0RsyKiDVgALBvkGiRJQ8CgnuLLzF0RcSlwJzAaWJKZqwazhkE2LE5V9jOPScc8LvvzmOxvRB2TQZ0kIUlSs7zVkSSpSAaUJKlIBtQAiIjPR8SvIuKhiPhWRExsWPfJ+jZPj0TEWa2sczBFxPkRsSoi9kTE3H3WjchjAt76a6+IWBIRGyPi4Ya2wyJieUQ8Vj8e2soaB1tETI+IH0TE6vrfzkfr9hFzXAyogbEcOC4zjwceBT4JUN/WaQHwOmA+8Lf17Z9GgoeB/wLc09g4ko9Jq279VaivUP35N7ocuCszZwN31c9Hkl3AJzLzGOAU4JL678eIOS4G1ADIzO9l5q766b1Un/eC6rZOt2Tmjsz8DbCG6vZPw15mrs7Mju4KMmKPCQ23/srMncDeW3+NOJl5D7Dv3TLPAZbWy0uBcwe1qBbLzPWZ+dN6+XlgNTCVEXRcDKiB90HgX+rlqcCTDevW1m0j2Ug+JiN535sxOTPXQ/XLGji8xfW0TETMBE4A7mMEHRe/D6qXIuL7wBEdrPp0Zt5e9/k01TD95r2bddB/2Mzzb+aYdLRZB23D5ph0YyTvu5oUEQcBtwEfy8zfxQj6plMDqpcy8x1drY+IhcC7gTPy9x82G9a3eurumHRiWB+TbozkfW/GhoiYkpnrI2IKsLHVBQ22iBhLFU43Z+Y36+YRc1w8xTcAImI+cBnw3szc1rBqGbAgIg6IiFnAbOD+VtRYkJF8TLz1V9eWAQvr5YVAZ6PwYSmqodKNwOrM/GLDqhFzXLyTxACIiDXAAcCzddO9mfnf63WfproutYtqyP4vHb/K8BIR7wO+DLQDW4EHM/Oset2IPCYAEfFO4H/y+1t/XdXikloiIr4GnE71dRIbgCuAbwO3AjOAJ4DzM3PEfO1oRJwG/BD4BbCnbv4U1XWoEXFcDChJUpE8xSdJKpIBJUkqkgElSSqSASVJKpIBJUkqkgElSSqSASVJKtL/B2rY+SJbwTvHAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe279674be0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot different bins using different styles\n",
    "axis = hist[hist.frequencies > 5].plot(label=\"High\", alpha=0.5)\n",
    "hist[1:-1][hist[1:-1].frequencies <= 5].plot(ax=axis, color=\"green\", label=\"Low\", alpha=0.5)\n",
    "hist[[0, -1]].plot(ax=axis, color=\"red\", label=\"Edge cases\", alpha=0.5)\n",
    "hist.plot(kind=\"scatter\", ax=axis, s=hist.frequencies / 10, label=\"Scatter\")\n",
    "# axis.legend();     # Does not work - why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe2796b81d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Bar plot with colormap (with logarithmic scale)\n",
    "ax = hist.plot(cmap=\"Reds_r\", yscale=\"log\", show_values=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Irregular binning and densities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe27950b080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure, axes = plt.subplots(1, 3, figsize=(11, 3))\n",
    "\n",
    "hist_irregular = histogram(heights, [160, 162, 166, 167, 175, 188, 191])\n",
    "hist_irregular.plot(ax=axes[0], errors=True, cmap=\"rainbow\");\n",
    "hist_irregular.plot(ax=axes[1], density=True, errors=True, cmap=\"rainbow\");\n",
    "hist_irregular.plot(ax=axes[2], density=True, cumulative=True, cmap=\"rainbow\");\n",
    "\n",
    "axes[0].set_title(\"Absolute values\")\n",
    "axes[1].set_title(\"Densities\")\n",
    "axes[2].set_title(\"Cumulative\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding new values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add (fill) single values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After 0 batches: Histogram1D(bins=(20,), total=9648, dtype=int64)\n",
      "After 1 batches: Histogram1D(bins=(20,), total=19648, dtype=int64)\n",
      "After 2 batches: Histogram1D(bins=(20,), total=29648, dtype=int64)\n",
      "After 3 batches: Histogram1D(bins=(20,), total=39251, dtype=int64)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe279321208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure, axes = plt.subplots(1, 4, figsize=(12, 3))\n",
    "\n",
    "hist3 = histogram([], 20, range=(160, 200))\n",
    "\n",
    "for i, ax in enumerate(axes):\n",
    "    for height in np.random.normal(165 + 10 * i, 2.8, 10000):\n",
    "        hist3.fill(height)\n",
    "    hist3.plot(ax=ax);\n",
    "    print(\"After {0} batches: {1}\".format(i, hist3))\n",
    "figure.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add histograms with same binning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe27acbc048>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "heights1 = histogram(np.random.normal(169, 10, 100000), 50, range=(150, 200))\n",
    "heights2 = histogram(np.random.normal(180, 11, 100000), 50, range=(150, 200))\n",
    "\n",
    "\n",
    "total = heights1 + heights2\n",
    "\n",
    "axis = heights1.plot(label=\"Women\", color=\"red\", alpha=0.5)\n",
    "heights2.plot(label=\"Men\", color=\"blue\", alpha=0.5, ax=axis)\n",
    "total.plot(label=\"All\", color=\"gray\", alpha=0.5, ax=axis)\n",
    "axis.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compatibility\n",
    "\n",
    "Note: Mostly, the compatibility is a trivial consequence of the object being convertible to numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left</th>\n",
       "      <th>right</th>\n",
       "      <th>frequency</th>\n",
       "      <th>error</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-26.890926</td>\n",
       "      <td>-21.481104</td>\n",
       "      <td>10</td>\n",
       "      <td>3.162278</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-21.481104</td>\n",
       "      <td>-16.071282</td>\n",
       "      <td>100</td>\n",
       "      <td>10.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-16.071282</td>\n",
       "      <td>-10.661460</td>\n",
       "      <td>534</td>\n",
       "      <td>23.108440</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-10.661460</td>\n",
       "      <td>-5.251638</td>\n",
       "      <td>1600</td>\n",
       "      <td>40.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-5.251638</td>\n",
       "      <td>0.158184</td>\n",
       "      <td>2803</td>\n",
       "      <td>52.943366</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.158184</td>\n",
       "      <td>5.568006</td>\n",
       "      <td>2850</td>\n",
       "      <td>53.385391</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>5.568006</td>\n",
       "      <td>10.977827</td>\n",
       "      <td>1544</td>\n",
       "      <td>39.293765</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>10.977827</td>\n",
       "      <td>16.387649</td>\n",
       "      <td>471</td>\n",
       "      <td>21.702534</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>16.387649</td>\n",
       "      <td>21.797471</td>\n",
       "      <td>75</td>\n",
       "      <td>8.660254</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>21.797471</td>\n",
       "      <td>27.207293</td>\n",
       "      <td>13</td>\n",
       "      <td>3.605551</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        left      right  frequency      error\n",
       "0 -26.890926 -21.481104         10   3.162278\n",
       "1 -21.481104 -16.071282        100  10.000000\n",
       "2 -16.071282 -10.661460        534  23.108440\n",
       "3 -10.661460  -5.251638       1600  40.000000\n",
       "4  -5.251638   0.158184       2803  52.943366\n",
       "5   0.158184   5.568006       2850  53.385391\n",
       "6   5.568006  10.977827       1544  39.293765\n",
       "7  10.977827  16.387649        471  21.702534\n",
       "8  16.387649  21.797471         75   8.660254\n",
       "9  21.797471  27.207293         13   3.605551"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert to pandas dataframe\n",
    "hist.to_dataframe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe277c402e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Works on xarray\n",
    "import xarray as xr\n",
    "arr = xr.DataArray(np.random.rand(10, 50, 100))\n",
    "histogram(arr).plot(cmap=\"Reds_r\", cmap_min=4744, cmap_max=5100, lw=1, edgecolor=\"red\", show_values=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(10,), total=100, dtype=int64)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe277b92b70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Works on pandas dataseries\n",
    "import pandas as pd\n",
    "series = pd.Series(heights, name=\"height [cm]\")\n",
    "hist = histogram(series, title=\"Height distribution\")\n",
    "hist.plot()\n",
    "hist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export & import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"histogram_type\": \"Histogram1D\", \"binnings\": [{\"adaptive\": false, \"binning_type\": \"NumpyBinning\", \"numpy_bins\": [144.46274207992508, 148.91498677707023, 153.36723147421537, 157.81947617136055, 162.2717208685057, 166.72396556565084, 171.176210262796, 175.62845495994114, 180.0806996570863, 184.53294435423146, 188.9851890513766]}], \"frequencies\": [2, 4, 4, 15, 11, 12, 19, 17, 7, 9], \"dtype\": \"int64\", \"errors2\": [2, 4, 4, 15, 11, 12, 19, 17, 7, 9], \"meta_data\": {\"name\": null, \"axis_names\": [\"height [cm]\"]}, \"missed\": [0, 0, 0], \"missed_keep\": true, \"physt_version\": \"0.3.39\", \"physt_compatible\": \"0.3.20\"}'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "json = hist.to_json()     # add path argument to write it to file\n",
    "json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Histogram1D(bins=(10,), total=100, dtype=int64)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAFc9JREFUeJzt3X+QZWV95/H3JwxaRkiA0CA/Bpp1kV1MlpF0BgyLQQzIr5XEmAhlRbLL1kRLUprV3R1jlVhm/yAxxqqIKzXKLJggsiZgqAwgs6wbtBbQnll+DEEWxLEYhmVGwUFK1gh89497Zrn03Dvd9O2Zfrr7/aq61ec85znnfOeB6c+c06efk6pCkqTW/Mx8FyBJ0iAGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJy+a7gEEOPvjgGh8fn+8yJEl7wIYNG75fVWPT9WsyoMbHx5mcnJzvMiRJe0CS782kn7f4JElNMqAkSU0yoCRJTTKgJElNMqAkSU2aNqCSLE/ytSQPJLk/yfu79oOSrE/yUPf1wCH7X9T1eSjJRXP9B5AkLU4zuYJ6DvhgVf1z4GTgfUmOB1YDt1XVscBt3fpLJDkIuBQ4CVgJXDosyCRJ6jdtQFXV41W1sVv+EfAAcARwPnB11+1q4DcG7P5WYH1VPVlVTwHrgbPmonBJ0uL2sn4GlWQceANwF3BoVT0OvRADDhmwyxHAo33rW7q2QcdelWQyyeT27dtfTlmSpEVoxgGVZD/gb4APVNXTM91tQFsN6lhVa6pqoqomxsamnQFDkrTIzSigkuxLL5yuqarru+YnkhzWbT8M2DZg1y3A8r71I4Gtsy9XkrRUzOQpvgBXAg9U1Z/3bboR2PlU3kXA3w7Y/avAmUkO7B6OOLNrkyRpt2ZyBXUK8LvA6Unu7j7nAJcBZyR5CDijWyfJRJLPA1TVk8AfA9/qPh/v2iRJ2q1UDfyR0LyamJgoZzOXpMUpyYaqmpiunzNJSJKaZEBJkppkQEmSmmRASZKaZEBJkpq0bL4LkNSm8dXr5ruEgTZfdu58l6C9xCsoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSk6adLDbJWuA8YFtV/WLXdh1wXNflAOCHVbViwL6bgR8BzwPPzeQVv5IkwcxmM78KuBz4ws6GqnrnzuUknwR27Gb/N1fV92dboCRpaZo2oKrq9iTjg7YlCfA7wOlzW5Ykaakb9WdQpwJPVNVDQ7YXcGuSDUlWjXguSdISMuoLCy8Ert3N9lOqamuSQ4D1Sb5dVbcP6tgF2CqAo446asSyJEkL3ayvoJIsA94OXDesT1Vt7b5uA24AVu6m75qqmqiqibGxsdmWJUlaJEa5xffrwLerasugjUlenWT/ncvAmcCmEc4nSVpCpg2oJNcCdwDHJdmS5OJu0wVMub2X5PAkN3WrhwLfSHIP8E1gXVXdMnelS5IWs5k8xXfhkPbfG9C2FTinW34EOGHE+iRJS9SoD0lI0l41vnrdfJcw0ObLzp3vEhYdpzqSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1adqASrI2ybYkm/raPpbksSR3d59zhux7VpIHkzycZPVcFi5JWtxmcgV1FXDWgPZPVdWK7nPT1I1J9gE+A5wNHA9cmOT4UYqVJC0d0wZUVd0OPDmLY68EHq6qR6rqH4EvAefP4jiSpCVo2Qj7XpLk3cAk8MGqemrK9iOAR/vWtwAnDTtYklXAKoCjjjpqhLLUgvHV6+a7hIE2X3bufJcgaYZm+5DEZ4HXAiuAx4FPDuiTAW017IBVtaaqJqpqYmxsbJZlSZIWi1kFVFU9UVXPV9ULwOfo3c6baguwvG/9SGDrbM4nSVp6ZhVQSQ7rW/1NYNOAbt8Cjk1yTJJXABcAN87mfJKkpWfan0EluRY4DTg4yRbgUuC0JCvo3bLbDPx+1/dw4PNVdU5VPZfkEuCrwD7A2qq6f4/8KSRJi860AVVVFw5ovnJI363AOX3rNwG7PIIuSdJ0nElCktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktSkaQMqydok25Js6mv7RJJvJ7k3yQ1JDhiy7+Yk9yW5O8nkXBYuSVrcZnIFdRVw1pS29cAvVtW/AP438OHd7P/mqlpRVROzK1GStBRNG1BVdTvw5JS2W6vquW71TuDIPVCbJGkJm4ufQf0b4OYh2wq4NcmGJKt2d5Akq5JMJpncvn37HJQlSVrIRgqoJB8BngOuGdLllKo6ETgbeF+SNw07VlWtqaqJqpoYGxsbpSxJ0iIw64BKchFwHvCuqqpBfapqa/d1G3ADsHK255MkLS2zCqgkZwH/EXhbVf14SJ9XJ9l/5zJwJrBpUF9JkqaayWPm1wJ3AMcl2ZLkYuByYH9gffcI+RVd38OT3NTteijwjST3AN8E1lXVLXvkTyFJWnSWTdehqi4c0HzlkL5bgXO65UeAE0aqTpK0ZE0bUJL2rPHV6+a7BKlJTnUkSWqSASVJapIBJUlqkgElSWqSASVJapIBJUlqkgElSWqSASVJapIBJUlqkgElSWqSUx1pSXFaIWnh8ApKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktSkGQVUkrVJtiXZ1Nd2UJL1SR7qvh44ZN+Luj4PJblorgqXJC1uM72Cugo4a0rbauC2qjoWuK1bf4kkBwGXAicBK4FLhwWZJEn9ZhRQVXU78OSU5vOBq7vlq4HfGLDrW4H1VfVkVT0FrGfXoJMkaRej/Azq0Kp6HKD7esiAPkcAj/atb+nadpFkVZLJJJPbt28foSxJ0mKwpx+SyIC2GtSxqtZU1URVTYyNje3hsiRJrRsloJ5IchhA93XbgD5bgOV960cCW0c4pyRpiRgloG4Edj6VdxHwtwP6fBU4M8mB3cMRZ3ZtkiTt1kwfM78WuAM4LsmWJBcDlwFnJHkIOKNbJ8lEks8DVNWTwB8D3+o+H+/aJEnarRm9D6qqLhyy6S0D+k4C/7ZvfS2wdlbVSZKWLGeSkCQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDVpRk/xSZIWnvHV6+a7hJF4BSVJapIBJUlqkgElSWqSASVJapIBJUlqkgElSWqSASVJapIBJUlqkgElSWqSASVJapIBJUlqkgElSWrSrAMqyXFJ7u77PJ3kA1P6nJZkR1+fj45esiRpKZj1bOZV9SCwAiDJPsBjwA0Dun69qs6b7XkkSUvTXN3iewvwnar63hwdT5K0xM1VQF0AXDtk2xuT3JPk5iSvn6PzSZIWuZEDKskrgLcBXx6weSNwdFWdAHwa+MpujrMqyWSSye3bt49aliRpgZuLK6izgY1V9cTUDVX1dFU90y3fBOyb5OBBB6mqNVU1UVUTY2Njc1CWJGkhm4uAupAht/eSvCZJuuWV3fl+MAfnlCQtcrN+ig8gyc8CZwC/39f2HoCqugJ4B/DeJM8BzwIXVFWNck5J0tIwUkBV1Y+BX5jSdkXf8uXA5aOcQ5K0NI0UUJKknvHV6+a7hEXHqY4kSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNGjmgkmxOcl+Su5NMDtieJH+R5OEk9yY5cdRzSpIWv2VzdJw3V9X3h2w7Gzi2+5wEfLb7KknSUHvjFt/5wBeq507ggCSH7YXzSpIWsLkIqAJuTbIhyaoB248AHu1b39K1vUSSVUkmk0xu3759DsqSJC1kcxFQp1TVifRu5b0vyZumbM+AfWqXhqo1VTVRVRNjY2NzUJYkaSEbOaCqamv3dRtwA7BySpctwPK+9SOBraOeV5K0uI0UUElenWT/ncvAmcCmKd1uBN7dPc13MrCjqh4f5bySpMVv1Kf4DgVuSLLzWF+sqluSvAegqq4AbgLOAR4Gfgz86xHPKUlaAkYKqKp6BDhhQPsVfcsFvG+U80iSlh5nkpAkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1aa4mi130xlevm+8SJGlJ8QpKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktSkWQdUkuVJvpbkgST3J3n/gD6nJdmR5O7u89HRypUkLRWjvG7jOeCDVbUxyf7AhiTrq+ofpvT7elWdN8J5JElL0KyvoKrq8ara2C3/CHgAOGKuCpMkLW1z8jOoJOPAG4C7Bmx+Y5J7ktyc5PW7OcaqJJNJJrdv3z4XZUmSFrCRAyrJfsDfAB+oqqenbN4IHF1VJwCfBr4y7DhVtaaqJqpqYmxsbNSyJEkL3EgBlWRfeuF0TVVdP3V7VT1dVc90yzcB+yY5eJRzSpKWhlGe4gtwJfBAVf35kD6v6fqRZGV3vh/M9pySpKVjlKf4TgF+F7gvyd1d2x8BRwFU1RXAO4D3JnkOeBa4oKpqhHNKkpaIWQdUVX0DyDR9Lgcun+05JElL1yhXUHvMfY/tYHz1uvkuQ5I0j5zqSJLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1CQDSpLUJANKktQkA0qS1KSRAirJWUkeTPJwktUDtr8yyXXd9ruSjI9yPknS0jHrgEqyD/AZ4GzgeODCJMdP6XYx8FRV/VPgU8CfzPZ8kqSlZZQrqJXAw1X1SFX9I/Al4Pwpfc4Hru6W/xp4S5KMcE5J0hKxbIR9jwAe7VvfApw0rE9VPZdkB/ALwPenHizJKmBVt/rM9/7kvAf7Nh88aJ9GLZRarXPuLZRaF0qdsHBqtc6X5+iZdBoloAZdCdUs+vQaq9YAawaeKJmsqomXV978WCi1WufcWyi1LpQ6YeHUap17xii3+LYAy/vWjwS2DuuTZBnw88CTI5xTkrREjBJQ3wKOTXJMklcAFwA3TulzI3BRt/wO4L9X1cArKEmS+s36Fl/3M6VLgK8C+wBrq+r+JB8HJqvqRuBK4C+TPEzvyumCWZ5u4K2/Ri2UWq1z7i2UWhdKnbBwarXOPSBe0EiSWuRMEpKkJhlQkqQmNRFQSdYm2ZZk04BtH0pSSQ7u1k9LsiPJ3d3no/NZZ5KPJXmsr55z+rZ9uJvm6cEkb22xziTjSZ7ta79ib9U5rNau/Q+6cbs/yZ/2tTczpsPqbHFMuynHdtazOcndfduaGdNhdTY6piuS3NnVM5lkZdeeJH/Rjem9SU5stM55+146Y1U17x/gTcCJwKYp7cvpPYTxPeDgru004O9aqRP4GPChAX2PB+4BXgkcA3wH2KfBOsenjnsDY/pm4L8Br+zWD2l0TIfV2dyYTtn+SeCjLY7pbupsbkyBW4Gzu+VzgP/Rt3wzvd8DPRm4q9E65+176Uw/TVxBVdXtDP79qE8B/4Ehv9y7t+2mzkHOB75UVT+pqu8CD9ObHmqPe5l1zqshtb4XuKyqftL12da1tzamw+qcV7v7758kwO8A13ZNrY3psDrn1ZBaC/i5bvnnefH3QM8HvlA9dwIHJDmswTqb10RADZLkbcBjVXXPgM1vTHJPkpuTvH5v1zbAJd2l/NokB3Ztg6aCOmLvl/YSg+oEOCbJ/0ry90lOnbfqXvQ64NT0ZsD/+yS/0rW3NqbD6oT2xnSnU4Enquqhbr21Md1pap3Q3ph+APhEkkeBPwM+3LW3NqbD6oT2vpe+RJMBleRngY8Ag+6JbgSOrqoTgE8DX9mbtQ3wWeC1wArgcXq3JeBlTPO0lwyr83HgqKp6A/DvgC8m+bnBh9hrlgEH0rs98u+B/9r9i7q1MR1WZ4tjutOFvPSqpLUx3WlqnS2O6XuBP6yq5cAf0vu9T2hvTIfV2dr30l00GVD0vpEeA9yTZDO9aZQ2JnlNVT1dVc8AVNVNwL7pHqCYD1X1RFU9X1UvAJ/jxdsjM5kKaq8ZVmd3a+cH3fIGej+DeN181dnZAlzf3SL5JvACvUkumxpThtTZ6JjunG7s7cB1fc2tjenAOhsd04uA67vlL9Po332G1Nna99JBmgyoqrqvqg6pqvGqGqf3H/zEqvo/SV7T/SuV7mmUnwF+MF+1Trm3/JvAzqdnbgQuSO+ljccAxwLf3Nv17TSsziRj6b3biyT/hF6dj+z9Cl/iK8DpAEleB7yC3gzMTY0pQ+psdEwBfh34dlVt6WtrbUxhQJ2NjulW4Ne65dOBnbcjbwTe3T3NdzKwo6oen48COwPrbO176UDz/ZRG9Z4muZbeJfxP6YXRxVO2b+bFp/guAe6n9+TRncCvzmedwF8C9wH30vsf87C+/h+h9y+9B+meommtTuC3+sZzI/Cv5vu/Pb1v9H9FL0Q3Aqc3OqYD62xxTLv2q4D3DOjfzJgOq7PFMQX+JbChq+ku4Je7vqH3MtfvdH/nJhqtc96+l87041RHkqQmNXmLT5IkA0qS1CQDSpLUJANKktQkA0qS1CQDSurTzZq9y6z60+zzniTvnqbP7yW5fMi2P9rNfs93M00f/nJqGnKsa5I8meQdox5L2hsMKGlEVXVFVX1hhEMMDSjg2apaUVUjz0RQVe+i9ztw0oJgQEm72ifJ59J7x9OtSV4FkOS1SW5JsiHJ15P8s679Y0k+1C3/Sjch7x1JPjHlauzwbv+H8uK7oy4DXtVdJV0zXWFJzkqysZvg87a+81/d1bo5yduT/GmS+7rz7TvXAyTtDQaUtKtjgc9U1euBH9KbxQBgDfAHVfXLwIeA/zxg3/9CbxaENwLPT9m2Angn8EvAO5Msr6rVvHiV9K7dFZVkjN48ir9VvQk+f7tv82uBc+m96uGvgK9V1S8Bz3bt0oKzbL4LkBr03ara+cbZDcB4kv2AXwW+3E1fBr2X/P1/SQ4A9q+q/9k1fRE4r6/LbVW1o+v7D8DRvPS1DNM5Gbi9eu9toqr63/tzc1X9NMl9wD7ALV37ffRe9ictOAaUtKuf9C0/D7yK3t2GH1bVit3sN+g1C7s77sv9+xeGv7Zh50sTX0jy03pxDrMXZnEeqQne4pNmoKqeBr6b5Leh98bXJCdM6fMU8KNuBmuAC2Z4+J/O8OdEdwC/1s06TpKDZnh8aUEyoKSZexdwcZJ76M0Cff6APhcDa5LcQe+KZ8cMjrsGuHe6hySqajuwCri+q+G63fWXFjpnM5fmUJL9qnsJXJLV9F5r8v4RjvdMVe03h/VdBfxdVf31XB1T2lO8gpLm1rndI+ObgFOB/zTi8Z6ey1/Upffiuv876rGkvcErKElSk7yCkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXp/wEATlNUklqDUQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fe277b5c748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from physt.io import parse_json\n",
    "hist = parse_json(json)\n",
    "hist.plot()\n",
    "hist"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernel_info": {
   "name": "python3"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  },
  "nteract": {
   "version": "0.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}