Merge pull request #11 from phobson/beef-it-up

Make the classes and functions more robust

Author: phobson

.gitignore

@@ -1,7 +1,6 @@
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
-result_images
 
 # C extensions
 *.so
@@ -43,6 +42,8 @@ htmlcov/
 nosetests.xml
 coverage.xml
 *,cover
+.noseids
+result_images
 
 # Translations
 *.mo
@@ -59,3 +60,8 @@ docs/tutorial/*_files/
 
 # PyBuilder
 target/
+
+# VS
+.vs
+*.pyproj
+*.sln

.travis.yml

@@ -5,9 +5,6 @@ matrix:
     - python: 2.7
       env:
         - COVERAGE=false
-    - python: 3.3
-      env:
-        - COVERAGE=false
     - python: 3.4
       env:
         - COVERAGE=false
@@ -24,7 +21,6 @@ before_install:
   - ./miniconda.sh -b -p $HOME/miniconda
   - export PATH="$HOME/miniconda/bin:$PATH"
   - conda update --yes conda
-  - cp probscale/tests/matplotlibrc .
 
 install:
 
@@ -33,13 +29,12 @@ install:
 
   - conda create --yes -n test python=$TRAVIS_PYTHON_VERSION
   - source activate test
-  #- conda config --add channels phobson
-  - conda install --yes numpy nose scipy matplotlib=1.4 coverage docopt requests pyyaml
+  - conda install --yes numpy nose scipy matplotlib coverage docopt requests pyyaml
   - pip install coveralls
   - pip install .
 
 script:
-  - nosetests --with-coverage --cover-package=probscale --verbose
+  - python check_probscale.py --with-coverage --cover-package=probscale --verbose
 
 after_success:
   - if [ ${COVERAGE} = true ]; then coveralls; fi

check_probscale.py

@@ -0,0 +1,5 @@
+import matplotlib
+matplotlib.use('agg')
+
+import nose
+nose.main()

docs/tutorial/getting_started.ipynb

@@ -31,6 +31,17 @@
     "collapsed": true
    },
    "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "import warnings\n",
     "warnings.simplefilter('ignore')\n",
@@ -41,8 +52,7 @@
     "import seaborn\n",
     "\n",
     "clear_bkgd = {'axes.facecolor':'none', 'figure.facecolor':'none'}\n",
-    "seaborn.set(style='ticks', context='notebook', rc=clear_bkgd)\n",
-    "%matplotlib inline"
+    "seaborn.set(style='ticks', context='notebook', rc=clear_bkgd)"
    ]
   },
   {
@@ -94,7 +104,7 @@
     "ax2.set_xlabel(\"Base 2\")\n",
     "ax2.set_yticks([])\n",
     "\n",
-    "seaborn.despine(fig=fig, left=True)\n"
+    "seaborn.despine(fig=fig, left=True)"
    ]
   },
   {
@@ -133,14 +143,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "It works after importing. Probability scales default to the standard normal distribution. Not that the formatting is a percentage-based probability."
+    "To access probability scales, simply import :py:mod:`probscale`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "scrolled": false
    },
    "outputs": [],
    "source": [
@@ -156,9 +167,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "Probability scales default to the standard normal distribution (ote that the formatting is a percentage-based probability)\n",
+    "\n",
     "You can even use different probability distributions, though it can be tricky. You have to pass a frozen distribution to the `dist` kwarg in `ax.set_[x|y]scale`.\n",
     "\n",
-    "Here's a standard normal scale right next to a beta scale ($\\alpha = 1$ and $\\beta = 1$) for comparison"
+    "Here's a standard normal scale right next to two different beta scales for comparison"
    ]
   },
   {
@@ -171,9 +184,7 @@
    "outputs": [],
    "source": [
     "import paramnormal\n",
-    "\n",
-    "beta1 = paramnormal.beta(α=3, β=2)\n",
-    "beta2 = paramnormal.beta(α=2, β=7)\n",
+    "seaborn.set(style='ticks', context='notebook', rc=clear_bkgd)\n",
     "\n",
     "fig, (ax1, ax2, ax3, ax4) = pyplot.subplots(figsize=(8, 5), nrows=4)\n",
     "\n",
@@ -182,11 +193,13 @@
     "ax1.set_xlabel('Normal probability scale')\n",
     "ax1.set_yticks([])\n",
     "\n",
+    "beta1 = paramnormal.beta(α=3, β=2)\n",
     "ax2.set_xscale('prob', dist=beta1)\n",
     "ax2.set_xlim(left=2, right=98)\n",
     "ax2.set_xlabel('Beta probability scale (α=3, β=2)')\n",
     "ax2.set_yticks([])\n",
     "\n",
+    "beta2 = paramnormal.beta(α=2, β=7)\n",
     "ax3.set_xscale('prob', dist=beta2)\n",
     "ax3.set_xlim(left=2, right=98)\n",
     "ax3.set_xlabel('Beta probability scale (α=2, β=7)')\n",
@@ -197,7 +210,7 @@
     "ax4.set_xlabel('Linear scale (for reference)')\n",
     "ax4.set_yticks([])\n",
     "\n",
-    "seaborn.despine(fig=fig, left=True)\n"
+    "seaborn.despine(fig=fig, left=True)"
    ]
   },
   {
@@ -292,10 +305,17 @@
    "metadata": {},
    "source": [
     "### Percentile and Quanitile plots\n",
-    "For convenience, you can do percetile and quantile plots with the same function.\n",
-    "\n",
+    "For convenience, you can do percetile and quantile plots with the same function."
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
     ".. note::\n",
-    "   The percentile and probability axes are plotted against the same values. The difference is only that \"percentiles\" are plotted on a linear scale."
+    "   The percentile and probability axes are plotted against the\n",
+    "   same values. The difference is only that \"percentiles\" \n",
+    "   are plotted on a linear scale."
    ]
   },
   {
@@ -334,4 +354,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 0
-}
+}

probscale/probscale.py

@@ -7,10 +7,29 @@
     NullLocator,
     Formatter,
     NullFormatter,
-    FuncFormatter
+    FuncFormatter,
 )
 
 
+def _mask_non_positives(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())