more robustness classes and better class names

Author: phobson

probscale/probscale.py

@@ -7,10 +7,29 @@
     NullLocator,
     Formatter,
     NullFormatter,
-    FuncFormatter
+    FuncFormatter,
 )
 
 
+def _mask_non_prop(a):
+    """
+    Return a Numpy array where all values outside ]0, 1[ are
+    replaced with NaNs. If all values are inside ]0, 1[, the original
+    array is returned.
+    """
+    mask = (a <= 0.0) | (a >= 1.0)
+    if mask.any():
+        return np.where(mask, np.nan, a)
+    return a
+
+
+def _clip_non_positives(a):
+    a = np.array(a, float)
+    a[a <= 0.0] = 1e-300
+    a[a >= 1.0] = 1 - 1e-300
+    return a
+
+
 class _minimal_norm(object):
     _A = -(8 * (np.pi - 3.0) / (3.0 * np.pi * (np.pi - 4.0)))
 
@@ -44,7 +63,6 @@ def ppf(cls, q):
         Wikipedia: https://goo.gl/Rtxjme
 
         """
-
         return np.sqrt(2) * cls._approx_inv_erf(2*q - 1)
 
     @classmethod
@@ -57,7 +75,7 @@ def cdf(cls, x):
         return 0.5 * (1 + cls._approx_erf(x/np.sqrt(2)))
 
 
-class ProbFormatter(Formatter):
+class _FormatterMixin(Formatter):
     @classmethod
     def _sig_figs(cls, x, n, expthresh=5, forceint=False):
         """ Formats a number with the correct number of sig figs.
@@ -128,49 +146,67 @@ def _sig_figs(cls, x, n, expthresh=5, forceint=False):
         return out
 
     def __call__(self, x, pos=None):
-        if x < 10:
+        if x < (10 / self.factor):
             out = self._sig_figs(x, 1)
-        elif x <= 99:
+        elif x <= (99 / self.factor):
             out =  self._sig_figs(x, 2)
         else:
-            order = np.ceil(np.round(np.abs(np.log10(100 - x)), 6))
-            out = self._sig_figs(x, order + 2)
+            order = np.ceil(np.round(np.abs(np.log10(self.top - x)), 6))
+            out = self._sig_figs(x, order + self.offset)
 
         return '{}'.format(out)
 
 
-class ProbTransform(Transform):
+class PctFormatter(_FormatterMixin):
+    factor = 1.0
+    offset = 2
+    top = 100
+
+
+class ProbFormatter(_FormatterMixin):
+    factor = 100.0
+    offset = 0
+    top = 1
+
+
+class _ProbTransformMixin(Transform):
     input_dims = 1
     output_dims = 1
     is_separable = True
     has_inverse = True
 
-    def __init__(self, dist):
+    def __init__(self, dist, as_pct=True, nonpos='mask'):
         Transform.__init__(self)
         self.dist = dist
+        if as_pct:
+            self.factor = 100.0
+        else:
+            self.factor = 1.0
 
-    def transform_non_affine(self, a):
-        return self.dist.ppf(a / 100.)
+        if nonpos == 'mask':
+            self._handle_nonpos = _mask_non_positives
+        elif nonpos == 'clip':
+            self._handle_nonpos = _clip_non_positives
+        else:
+            raise ValueError("`nonpos` muse be either 'mask' or 'clip'")
 
-    def inverted(self):
-        return InvertedProbTransform(self.dist)
 
+class ProbTransform(_ProbTransformMixin):
+    def transform_non_affine(self, prob):
+        q = self.dist.ppf(prob / self.factor)
+        return q
 
-class InvertedProbTransform(Transform):
-    input_dims = 1
-    output_dims = 1
-    is_separable = True
-    has_inverse = True
+    def inverted(self):
+        return QuantileTransform(self.dist, as_pct=self.as_pct, nonpos=self.nonpos)
 
-    def __init__(self, dist):
-        self.dist = dist
-        Transform.__init__(self)
 
-    def transform_non_affine(self, a):
-        return self.dist.cdf(a) * 100.
+class QuantileTransform(_ProbTransformMixin):
+    def transform_non_affine(self, q):
+        prob = self.dist.cdf(q) * self.factor
+        return prob
 
     def inverted(self):
-        return ProbTransform(self.dist)
+        return ProbTransform(self.dist, as_pct=self.as_pct, nonpos=self.nonpos)
 
 
 class ProbScale(ScaleBase):
@@ -199,13 +235,19 @@ class ProbScale(ScaleBase):
 
     def __init__(self, axis, **kwargs):
         self.dist = kwargs.pop('dist', _minimal_norm)
-        self._transform = ProbTransform(self.dist)
+        self.as_pct = kwargs.pop('as_pct', True)
+        self.nonpos = kwargs.pop('nonpos', 'mask')
+        self._transform = ProbTransform(self.dist, as_pct=self.as_pct)
 
     @classmethod
-    def _get_probs(cls, nobs):
+    def _get_probs(cls, nobs, as_pct):
         """ Returns the x-axis labels for a probability plot based on
         the number of observations (`nobs`).
         """
+        if as_pct:
+            factor = 1.0
+        else:
+            factor = 100.0
 
         order = int(np.floor(np.log10(nobs)))
         base_probs = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90])
@@ -219,19 +261,23 @@ def _get_probs(cls, nobs):
                 lower_fringe = np.array([1])
                 upper_fringe = np.array([9])
 
-            new_lower = lower_fringe/10**(n)
-            new_upper = upper_fringe/10**(n) + axis_probs.max()
+            new_lower = lower_fringe / 10**(n)
+            new_upper = upper_fringe / 10**(n) + axis_probs.max()
             axis_probs = np.hstack([new_lower, axis_probs, new_upper])
-
-        return axis_probs
+        locs = axis_probs / factor
+        return locs
 
     def set_default_locators_and_formatters(self, axis):
         """
         Set the locators and formatters to specialized versions for
         log scaling.
         """
-        axis.set_major_locator(FixedLocator(self._get_probs(1e10)))
-        axis.set_major_formatter(FuncFormatter(ProbFormatter()))
+
+        axis.set_major_locator(FixedLocator(self._get_probs(1e8, self.as_pct)))
+        if self.as_pct:
+            axis.set_major_formatter(FuncFormatter(PctFormatter()))
+        else:
+            axis.set_major_formatter(FuncFormatter(ProbFormatter()))
         axis.set_minor_locator(NullLocator())
         axis.set_minor_formatter(NullFormatter())
 

probscale/tests/test_probscale/test_probscale.py

@@ -73,7 +73,7 @@ def test_cdf(self):
 
 
 class Mixin_ProbFormatter_sig_figs(object):
-    fmt = probscale.ProbFormatter()
+    fmt = probscale.PctFormatter()
     def teardown(self):
         pass
 
@@ -110,6 +110,7 @@ def test_forceint(self):
 
     def test__call__(self):
         nt.assert_equal(self.fmt(0.0301), '0.03')
+        nt.assert_equal(self.fmt(0.2), '0.2')
         nt.assert_equal(self.fmt(0.1), '0.1')
         nt.assert_equal(self.fmt(10), '10')
         nt.assert_equal(self.fmt(5), '5')
@@ -181,7 +182,7 @@ def setup(self):
         self.known_tras_na = -2.569150498
 
 
-class Test_InvertedProbTransform(Mixin_Transform):
+class Test_QuantileTransform(Mixin_Transform):
     def setup(self):
-        self.trans = probscale.InvertedProbTransform(probscale._minimal_norm)
+        self.trans = probscale.QuantileTransform(probscale._minimal_norm)
         self.known_tras_na = 69.1464492