Doc cleanup for v0.7.2 release

doc/api.rst

@@ -144,7 +144,6 @@ Computation
 :py:attr:`~Dataset.round`
 :py:attr:`~Dataset.real`
 :py:attr:`~Dataset.T`
-:py:attr:`~DataArray.dot`
 
 **Grouped operations**:
 :py:attr:`~core.groupby.DatasetGroupBy.assign`
@@ -251,6 +250,7 @@ Computation
    DataArray.resample
    DataArray.get_axis_num
    DataArray.diff
+   DataArray.dot
 
 **Aggregation**:
 :py:attr:`~DataArray.all`

doc/computation.rst

@@ -99,6 +99,8 @@ These operations automatically skip missing values, like in pandas:
 If desired, you can disable this behavior by invoking the aggregation method
 with ``skipna=False``.
 
+.. _comput.rolling:
+
 Rolling window operations
 =========================
 
@@ -134,6 +136,12 @@ Aggregation and summary methods can be applied directly to the ``Rolling`` objec
     r.mean()
     r.reduce(np.std)
 
+Note that rolling window aggregations are much faster (both asymptotically and
+because they avoid a loop in Python) when bottleneck_ is installed. Otherwise,
+we fall back to a slower, pure Python implementation.
+
+.. _bottleneck: https://github.com/kwgoodman/bottleneck/
+
 Finally, we can manually iterate through ``Rolling`` objects:
 
 .. ipython:: python

doc/installing.rst

@@ -25,7 +25,7 @@ For accelerating xarray
 ~~~~~~~~~~~~~~~~~~~~~~~
 
 - `bottleneck <https://github.com/kwgoodman/bottleneck>`__: speeds up
-  NaN-skipping aggregations by a large factor
+  NaN-skipping and rolling window aggregations by a large factor
 - `cyordereddict <https://github.com/shoyer/cyordereddict>`__: speeds up most
   internal operations with xarray data structures
 

doc/whats-new.rst

@@ -1,3 +1,5 @@
+.. currentmodule:: xarray
+
 What's New
 ==========
 
@@ -13,16 +15,21 @@ What's New
 
 .. _whats-new.0.7.2:
 
-v0.7.2 (unreleased)
--------------------
+v0.7.2 (13 March 2016)
+----------------------
+
+This release includes two new, entirely backwards compatible features and
+several bug fixes.
 
 Enhancements
 ~~~~~~~~~~~~
--xarray version of np.dot :py:meth:`~DataArray.dot`. Performs dot product of 
-two DataArrays along their shared dims
+
+- New DataArray method :py:meth:`DataArray.dot` for calculating the dot
+  product of two DataArrays along shared dimensions. By
+  `Dean Pospisil <https://github.com/deanpospisil>`_.
 
 - Rolling window operations on DataArray objects are now supported via a new
-  :py:meth:`xarray.DataArray.rolling` method.
+  :py:meth:`DataArray.rolling` method. For example:
 
   .. ipython::
     :verbatim:
@@ -52,15 +59,21 @@ two DataArrays along their shared dims
       * x        (x) int64 0 1 2
       * y        (y) int64 0 1 2 3 4
 
+  See :ref:`comput.rolling` for more details. By
+  `Joe Hamman <https://github.com/jhamman>`_.
+
 Bug fixes
 ~~~~~~~~~
 
 - Fixed an issue where plots using pcolormesh and Cartopy axes were being distorted
   by the inference of the axis interval breaks. This change chooses not to modify
   the coordinate variables when the axes have the attribute ``projection``, allowing
-  Cartopy to handle the extent of pcolormesh plots (:issue:`781`).
-- 2D plots now better handle additional coordinates which are not linked to the
-  dimensions of ``DataArray`` (:issue:`788`).
+  Cartopy to handle the extent of pcolormesh plots (:issue:`781`). By
+  `Joe Hamman <https://github.com/jhamman>`_.
+
+- 2D plots now better handle additional coordinates which are not ``DataArray``
+  dimensions (:issue:`788`). By `Fabien Maussion <https://github.com/fmaussion>`_.
+
 
 .. _whats-new.0.7.1:
 

xarray/core/common.py

@@ -345,7 +345,10 @@ def groupby(self, group, squeeze=True):
 
     def rolling(self, min_periods=None, center=False, **windows):
         """
-        Moving window object.
+        Rolling window object.
+
+        Rolling window aggregations are much faster when bottleneck is
+        installed.
 
         Parameters
         ----------