ENH-19629: Adding numpy nansun/nanmean, etc etc to _cython_table

doc/source/whatsnew/v0.23.0.txt

@@ -747,7 +747,7 @@ Numeric
 - Bug in the :class:`DataFrame` constructor in which data containing very large positive or very large negative numbers was causing ``OverflowError`` (:issue:`18584`)
 - Bug in :class:`Index` constructor with ``dtype='uint64'`` where int-like floats were not coerced to :class:`UInt64Index` (:issue:`18400`)
 - Bug in :class:`DataFrame` flex arithmetic (e.g. `df.add(other, fill_value=foo)`) with a `fill_value` other than ``None`` failed to raise ``NotImplementedError`` in corner cases where either the frame or ``other`` has length zero (:issue:`19522`)
-
+- :meth:`~DataFrame.agg` now correctly handles numpy NaN-aware methods like :meth:`numpy.nansum` (:issue:`19629`)
 
 Indexing
 ^^^^^^^^

pandas/core/base.py

@@ -187,15 +187,25 @@ class SelectionMixin(object):
         builtins.max: 'max',
         builtins.min: 'min',
         np.sum: 'sum',
+        np.nansum: 'sum',
         np.mean: 'mean',
+        np.nanmean: 'mean',
         np.prod: 'prod',
+        np.nanprod: 'prod',
         np.std: 'std',
+        np.nanstd: 'std',
         np.var: 'var',
+        np.nanvar: 'var',
         np.median: 'median',
+        np.nanmedian: 'median',
         np.max: 'max',
+        np.nanmax: 'max',
         np.min: 'min',
+        np.nanmin: 'min',
         np.cumprod: 'cumprod',
-        np.cumsum: 'cumsum'
+        np.nancumprod: 'cumprod',
+        np.cumsum: 'cumsum',
+        np.nancumsum: 'cumsum'
     }
 
     @property

pandas/tests/test_nanops.py

@@ -1004,6 +1004,95 @@ def prng(self):
         return np.random.RandomState(1234)
 
 
+class TestNumpyNaNFunctions(object):
+
+    # xref GH 19629
+
+    def setup_method(self, method):
+        self.test_series = pd.Series([1, 2, 3, 4, 5, 6])
+        self.test_df = pd.DataFrame([[1, 2, 3], [4, 5, 6]])
+
+    def test_np_sum(self):
+        tm.assert_almost_equal(self.test_series.agg(np.sum),
+                               self.test_series.agg(np.nansum),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.sum),
+                               self.test_df.agg(np.nansum),
+                               check_exact=True)
+
+    def test_np_mean(self):
+        tm.assert_almost_equal(self.test_series.agg(np.mean),
+                               self.test_series.agg(np.nanmean),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.mean),
+                               self.test_df.agg(np.nanmean),
+                               check_exact=True)
+
+    def test_np_prod(self):
+        tm.assert_almost_equal(self.test_series.agg(np.prod),
+                               self.test_series.agg(np.nanprod),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.prod),
+                               self.test_df.agg(np.nanprod),
+                               check_exact=True)
+
+    def test_np_std(self):
+        tm.assert_almost_equal(self.test_series.agg(np.std),
+                               self.test_series.agg(np.nanstd),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.std),
+                               self.test_df.agg(np.nanstd),
+                               check_exact=True)
+
+    def test_np_var(self):
+        tm.assert_almost_equal(self.test_series.agg(np.var),
+                               self.test_series.agg(np.nanvar),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.var),
+                               self.test_df.agg(np.nanvar),
+                               check_exact=True)
+
+    def test_np_median(self):
+        tm.assert_almost_equal(self.test_series.agg(np.median),
+                               self.test_series.agg(np.nanmedian),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.median),
+                               self.test_df.agg(np.nanmedian),
+                               check_exact=True)
+
+    def test_np_max(self):
+        tm.assert_almost_equal(self.test_series.agg(np.max),
+                               self.test_series.agg(np.nanmax),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.max),
+                               self.test_df.agg(np.nanmax),
+                               check_exact=True)
+
+    def test_np_min(self):
+        tm.assert_almost_equal(self.test_series.agg(np.min),
+                               self.test_series.agg(np.nanmin),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.min),
+                               self.test_df.agg(np.nanmin),
+                               check_exact=True)
+
+    def test_np_cumprod(self):
+        tm.assert_almost_equal(self.test_series.agg(np.cumprod),
+                               self.test_series.agg(np.nancumprod),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.cumprod),
+                               self.test_df.agg(np.nancumprod),
+                               check_exact=True)
+
+    def test_np_cumsum(self):
+        tm.assert_almost_equal(self.test_series.agg(np.cumsum),
+                               self.test_series.agg(np.nancumsum),
+                               check_exact=True)
+        tm.assert_almost_equal(self.test_df.agg(np.cumsum),
+                               self.test_df.agg(np.nancumsum),
+                               check_exact=True)
+
+
 def test_use_bottleneck():
 
     if nanops._BOTTLENECK_INSTALLED: