Merge pull request #35 from histogrammar/1.0.x

1.0.x

Author: mbaak

.travis.yml

@@ -4,10 +4,11 @@ os:
   - linux
 
 python:
-  - 2.6
   - 2.7
   - 3.4
   - 3.5
+  - 3.6
+  - 3.7
 
 addons:
   apt:

README.md

@@ -5,7 +5,12 @@ Python implementation of Histogrammar
 
 See [histogrammar.org](http://histogrammar.org) for a complete introduction to Histogrammar.
 
-This is a pure Python implementation for Python versions 2.6, 2.7, and 3.4.
+This is a pure Python implementation for Python versions 2.7, and 3.4, 3.5, 3.6, 3.7
+
+Latest Python release: v1.0.10 (Sep 2019).
+
+Support of Histogrammar is provided on a best-effort basis only.
+
 
 Installation
 ============

docs/conf.py

@@ -47,9 +47,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = "1.0.8"
+version = "1.0.10"
 # The full version, including alpha/beta/rc tags.
-release = "1.0.8"
+release = "1.0.10"
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

histogrammar/plot/matplotlib.py

@@ -67,42 +67,6 @@ def plotmatplotlib(self, name=None, **kwargs):
 
         return ax
 
-    def num_bins(self):
-        """
-        Returns number of bins
-        """
-        return len(self.values)
-    
-    def bin_width(self):
-        """
-        Returns bin width
-        """
-        return (self.high - self.low) / self.num_bins()
-    
-    def bin_entries(self):
-        """
-        Returns bin values
-        """
-        import numpy as np
-        return np.array([x.entries for x in self.values])
-
-    def bin_edges(self):
-        """
-        Returns bin edges
-        """
-        import numpy as np
-        num_bins = self.num_bins()
-        edges = np.linspace(self.low, self.high, num_bins + 1)
-        return edges
-
-    def bin_centers(self):
-        """
-        Returns bin centers
-        """
-        import numpy as np
-        return np.array([sum(self.range(i))/2.0 for i in self.indexes])
-
-
 class SparselyHistogramMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
         """
@@ -129,58 +93,6 @@ def plotmatplotlib(self, name=None, **kwargs):
 
         return ax
 
-    def num_bins(self):
-        """
-        Returns number of bins
-        """
-        if self.minBin is None or self.maxBin is None:
-            return 0
-        nbins = self.maxBin - self.minBin + 1
-        return nbins
-    
-    def bin_width(self):
-        """
-        Returns bin width
-        """
-        return self.binWidth
-
-    def bin_edges(self):
-        """
-        Returns bin_edges
-        """
-        import numpy as np
-
-        if self.minBin is None or self.maxBin is None:
-            edges = np.array([self.origin, self.origin + 1])
-        else:
-            num_bins = self.maxBin - self.minBin + 1
-            edges = np.linspace(self.low, self.high, num_bins + 1)
-        return edges
-    
-    def bin_entries(self):
-        """
-        Returns bin values
-        """
-        import numpy as np
-
-        if self.minBin is None or self.maxBin is None:
-            entries = [self.bins[0].entries]
-        else:
-            entries = [self.bins[i].entries if i in self.bins else 0.0 \
-                       for i in range(self.minBin, self.maxBin + 1)]
-        return np.array(entries)
-
-    def bin_centers(self):
-        """
-        Returns bin centers
-        """
-        import numpy as np
-
-        bin_edges = self.bin_edges()
-        centers = [(bin_edges[i]+bin_edges[i+1])/2. for i in range(len(bin_edges)-1)]
-        return np.array(centers)
-        
-
 class CategorizeHistogramMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
         """
@@ -223,28 +135,6 @@ def xtick(lab):
 
         return ax
 
-    def bin_entries(self):
-        """
-        Returns bin values
-        """
-        import numpy as np
-        return np.array([self.bins[i].entries for i in self.bins])
-
-    def bin_labels(self):
-        """
-        Returns bin labels
-        """
-        import numpy as np
-        labels = []
-        for i,key in enumerate(self.bins.keys()):
-            try:
-                label = str(key)
-            except:
-                label = 'bin_%d' % i
-            labels.append(label)
-        return np.asarray(labels)
-
-
 class ProfileMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
         """ Plotting method for Bin of Average

histogrammar/primitives/bin.py

@@ -84,6 +84,7 @@ def ed(low, high, entries, values, underflow, overflow, nanflow):
         out = Bin(len(values), float(low), float(high), None, None, underflow, overflow, nanflow)
         out.entries = float(entries)
         out.values = values
+        out.contentType = values[0].name
         return out.specialize()
 
     @staticmethod
@@ -134,8 +135,10 @@ def __init__(self, num, low, high, quantity, value=Count(), underflow=Count(), o
         self.quantity = serializable(quantity)
         if value is None:
             self.values = [None] * num
+            self.contentType = "Count"
         else:
             self.values = [value.zero() for i in xrange(num)]
+            self.contentType = value.name
         self.underflow = underflow.copy()
         self.overflow = overflow.copy()
         self.nanflow = nanflow.copy()
@@ -622,5 +625,204 @@ def __ne__(self, other): return not self == other
     def __hash__(self):
         return hash((self.low, self.high, self.quantity, self.entries, tuple(self.values), self.underflow, self.overflow, self.nanflow))
 
+    @property
+    def n_bins(self):
+        """Get number of bins, consistent with SparselyBin and Categorize """
+        return self.num
+
+    @property
+    def n_dim(self):
+        """Histogram dimension
+
+        :returns: dimension of the histogram
+        :rtype: int
+        """
+        return get_n_dim(self)
+
+    def num_bins(self, low=None, high=None):
+        """
+        Returns number of bins
+
+        Possible to set range with low and high params
+
+        :param low: lower edge of range, default is None
+        :param high: higher edge of range, default is None
+        :returns: number of bins in range
+        :rtype: int
+        """
+        import numpy as np
+        # trivial cases first
+        if low is None and high is None:
+            return len(self.values)
+        # catch weird cases
+        elif low is not None and high is not None:
+            if low > high:
+                raise RuntimeError('low {low} greater than high {high}'.format(low=low, high=high))
+            if low < self.low and high < self.low:
+                # note: all these data end up in the underflow bin, with no real index
+                return 0
+            if low >= self.high and high >= self.high:
+                # note: all these data end up in the overflow bin, with no real index
+                return 0
+        # lowest edge
+        if low is None or low < self.low:
+            low = self.low
+        else:  # low >= self.low and low < self.high
+            minBin = self.bin(low)
+            low = self.low + self.bin_width() * minBin
+        # highest edge
+        if high is None or high >= self.high:
+            high = self.high
+        else:  # high < self.high and high >= self.low
+            maxBin = self.bin(high)
+            if np.isclose(high, self.low + self.bin_width() * maxBin):
+                maxBin -= 1
+            high = self.low + self.bin_width() * (maxBin + 1)
+        # number of bins
+        num_bins = int((high - low) / self.bin_width())
+        return num_bins
+
+    def bin_width(self):
+        """
+        Returns bin width
+        """
+        return (self.high - self.low) / len(self.values)
+
+    def bin_entries(self, low=None, high=None, xvalues=[]):
+        """
+        Returns bin values
+
+        Possible to set range with low and high params, and list of selected x-values
+
+        :param low: lower edge of range, default is None
+        :param high: higher edge of range, default is None
+        :param xvalues: list of x-values to get entries of, alternative to low and high
+        :returns: numpy array with numbers of entries for selected bins
+        :rtype: numpy.array
+        """
+        import numpy as np
+        # trivial case
+        if low is None and high is None and len(xvalues) == 0:
+            return np.array([x.entries for x in self.values])
+        # catch weird cases
+        elif low is not None and high is not None and len(xvalues) == 0:
+            if low > high:
+                raise RuntimeError('low {low} greater than high {high}'.format(low=low, high=high))
+            if low < self.low and high < self.low:
+                # note: all these data end up in the underflow bin
+                return np.array([])
+            if low >= self.high and high >= self.high:
+                # note: all these data end up in the overflow bin
+                return np.array([])
+        # entries at request list of x-values
+        elif len(xvalues) > 0:
+            entries = [self.values[self.bin(x)].entries if self.bin(x) in self.indexes else 0.0 for x in xvalues]
+            return np.array(entries)
+        # lowest edge
+        if low is None or low < self.low:
+            minBin = 0
+        else:  # low >= self.low and low < self.high
+            minBin = self.bin(low)
+        # highest edge
+        if high is None or high >= self.high:
+            maxBin = len(self.values) - 1
+        else:  # high < self.high and high >= self.low
+            maxBin = self.bin(high)
+            if np.isclose(high, self.low + self.bin_width() * maxBin):
+                maxBin -= 1
+        return np.array([self.values[i].entries for i in range(minBin, maxBin + 1)])
+
+    def bin_edges(self, low=None, high=None):
+        """
+        Returns bin edges
+
+        :param low: lower edge of range, default is None
+        :param high: higher edge of range, default is None
+        :returns: numpy array with bin edges for selected range
+        :rtype: numpy.array
+        """
+        import numpy as np
+        num_bins = self.num_bins(low, high)
+        # trivial cases first
+        if low is None and high is None:
+            return np.linspace(self.low, self.high, num_bins + 1)
+        # catch weird cases
+        elif low is not None and high is not None:
+            if low > high:
+                raise RuntimeError('low {low} greater than high {high}'.format(low=low, high=high))
+            if low < self.low and high < self.low:
+                # note: all these data end up in the underflow bin
+                return np.linspace(self.low, self.low, num_bins + 1)
+            if low >= self.high and high >= self.high:
+                # note: all these data end up in the overflow bin
+                return np.linspace(self.high, self.high, num_bins + 1)
+        # lowest edge
+        if low is None or low < self.low:
+            low = self.low
+        else:  # low >= self.low and low < self.high
+            minBin = self.bin(low)
+            low = self.low + self.bin_width() * minBin
+        # highest edge
+        if high is None or high >= self.high:
+            high = self.high
+        else:  # high < self.high and high >= self.low
+            maxBin = self.bin(high)
+            if np.isclose(high, self.low + self.bin_width() * maxBin):
+                maxBin -= 1
+            high = self.low + self.bin_width() * (maxBin + 1)
+
+        edges = np.linspace(low, high, num_bins + 1)
+        return edges
+
+    def bin_centers(self, low=None, high=None):
+        """
+        Returns bin centers
+
+        :param low: lower edge of range, default is None
+        :param high: higher edge of range, default is None
+        :returns: numpy array with bin centers for selected range
+        :rtype: numpy.array
+        """
+        import numpy as np
+        # trivial case
+        if low is None and high is None:
+            return np.array([sum(self.range(i)) / 2.0 for i in self.indexes])
+        # catch weird cases
+        elif low is not None and high is not None:
+            if low > high:
+                raise RuntimeError('low {low} greater than high {high}'.format(low=low, high=high))
+            if low < self.low and high < self.low:
+                # note: all these data end up in the underflow bin
+                return np.array([])
+            if low >= self.high and high >= self.high:
+                # note: all these data end up in the overflow bin
+                return np.array([])
+        # lowest edge
+        if low is None or low < self.low:
+            minBin = 0
+        else:  # low >= self.low and low < self.high
+            minBin = self.bin(low)
+        # highest edge
+        if high is None or high >= self.high:
+            maxBin = len(self.values) - 1
+        else:  # high < self.high and high >= self.low
+            maxBin = self.bin(high)
+            if np.isclose(high, self.low + self.bin_width() * maxBin):
+                maxBin -= 1
+
+        return np.array([sum(self.range(i)) / 2.0 for i in range(minBin, maxBin + 1)])
+
+    @property
+    def mpv(self):
+        """Return bin-center of most probable value
+        """
+        bin_entries = self.bin_entries()
+        bin_centers = self.bin_centers()
+
+        # if two max elements are equal, this will return the element with the lowest index.
+        max_idx = max(enumerate(bin_entries), key=lambda x: x[1])[0]
+        bc = bin_centers[max_idx]
+        return bc
+
 Factory.register(Bin)