ADD: NDVar.var()

eelbrain/_data_obj.py

@@ -26,6 +26,7 @@
 from collections import Iterator, OrderedDict, Sequence
 from copy import deepcopy
 from fnmatch import fnmatchcase
+from functools import partial
 import itertools
 from itertools import chain, izip
 from keyword import iskeyword
@@ -4633,6 +4634,36 @@ def threshold(self, v, tail=1, name=None):
         return NDVar(np.where(idx, self.x, 0), self.dims, info,
                      name or self.name)
 
+    def var(self, dims=(), ddof=0, **regions):
+        """Compute the variance over given dimensions
+
+        Parameters
+        ----------
+        dims : str | tuple of str | boolean NDVar
+            Dimensions over which to operate. A str is used to specify a single
+            dimension, a tuple of str to specify several dimensions, None to
+            compute the sum over all dimensions.
+            An boolean NDVar with the same dimensions as the data can be used
+            to compute the variance in specific elements (if the data has a case
+            dimension, the variance is computed for each case).
+        *regions*
+            Regions over which to aggregate. For example, to get the variance
+            between time=0.1 and time=0.2, use ``ndvar.var(time=(0.1, 0.2))``.
+        ddof : int
+            Degrees of freedom (default 0; see :func:`numpy.var`).
+        name : str
+            Name of the output NDVar (default is the current name).
+
+        Returns
+        -------
+        var : NDVar | Var | float
+            The variance over specified dimensions. Returns a Var if only the
+            case dimension remains, and a float if the function collapses over
+            all data.
+        """
+        return self._aggregate_over_dims(dims, regions,
+                                         partial(np.var, ddof=ddof))
+
 
 def extrema(x, axis=0):
     "Extract the extreme values in x"

eelbrain/tests/test_data.py

@@ -1055,6 +1055,16 @@ def test_ndvar_summary_methods():
     assert_array_equal(x.min(idxsub), xsub.min(idxsub))
     assert_array_equal(x.min(idx1d), x.x[:, idx1d.x].min(1))
 
+    eq_(x.var(), x.x.var())
+    eq_(x.var(ddof=1), x.x.var(ddof=1))
+    assert_array_equal(x.var(dim), x.x.var(axis))
+    assert_array_equal(x.var(dims, ddof=1), x.x.var(axes, ddof=1))
+    assert_array_equal(x.var(idx0), [x_[idx0.x].var() for x_ in x.x])
+    assert_array_equal(x.var(idx), [x_[i].var() for x_, i in izip(x.x, idx.x)])
+    assert_array_equal(x0.var(idx0), x0.x[idx0.x].var())
+    assert_array_equal(x.var(idxsub), xsub.var(idxsub))
+    assert_array_equal(x.var(idx1d), x.x[:, idx1d.x].var(1))
+
     eq_(x.std(), x.x.std())
     assert_array_equal(x.std(dim), x.x.std(axis))
     assert_array_equal(x.std(dims), x.x.std(axes))